  ogdf::Array< List< edge > > | |
  ogdf::KuratowskiSubdivision | |
| ogdf::Array< node > | |
| ogdf::ShellingOrderSet | The node set in a shelling order of a graph |
 ogdf::Array< Prioritized< X *, Priority >, INDEX > | |
| ogdf::Array< T > | |
| ogdf::HyperGraph::GraphArray< T, AdjElement > | |
| ogdf::HyperGraph::AdjArray< T > | Dynamic arrays indexed with adjacency entries |
| ogdf::HyperGraph::GraphArray< T, EdgeElement > | |
| ogdf::HyperGraph::EdgeArray< T > | Dynamic arrays indexed with hyper edges |
| ogdf::HyperGraph::GraphArray< T, NodeElement > | |
| ogdf::HyperGraph::NodeArray< T > | Dynamic arrays indexed with nodes |
| ogdf::AdjEntryArray< T > | Dynamic arrays indexed with adjacency entries |
| ogdf::ClusterArray< T > | Dynamic arrays indexed with clusters |
| ogdf::EdgeArray< T > | Dynamic arrays indexed with edges |
| ogdf::FaceArray< T > | Dynamic arrays indexed with faces of a combinatorial embedding |
| ogdf::HyperGraph::GraphArray< T, E > | |
| ogdf::NodeArray< T > | Dynamic arrays indexed with nodes |
| ogdf::BinaryHeapSimple< Prioritized< X *, Priority >, INDEX > | |
| ogdf::BucketFunc< edge > | |
| ogdf::BucketEdgeArray | Bucket function for edges |
| ogdf::BucketSourceIndex | Bucket function using the index of an edge's source node as bucket |
| ogdf::BucketTargetIndex | Bucket function using the index of an edge's target node as bucket |
| ogdf::BucketFunc< node > | |
| ogdf::BucketLowPoint | BucketFunction for lowPoint buckets |
| ogdf::GenericPoint< double > | |
 ogdf::DPoint | Real points |
 ogdf::DVector | Vectors with real coordinates |
| ogdf::GenericPoint< int > | |
| ogdf::IPoint | Integer points |
| ogdf::HyperGraph::GraphArrayBase< AdjElement > | |
| ogdf::HyperGraph::GraphArray< T, AdjElement > | |
| ogdf::HyperGraph::GraphArrayBase< EdgeElement > | |
| ogdf::HyperGraph::GraphArray< T, EdgeElement > | |
| ogdf::HyperGraph::GraphArrayBase< NodeElement > | |
| ogdf::HyperGraph::GraphArray< T, NodeElement > | |
| ogdf::HashConstIterator< Tuple2< I1_, I2_ >, E_, HashFuncTuple< I1_, I2_, Hash1_, Hash2_ > > | |
| ogdf::HashConstIterator2D< I1_, I2_, E_, Hash1_, Hash2_ > | Const-iterator for 2D-hash arrays |
| ogdf::HashFuncTuple< I1, I2, H1, H2 > | |
| ogdf::HashFuncTuple< I1_, I2_, Hash1_, Hash2_ > | |
| ogdf::HeapBase< key, HeapObject > | |
| ogdf::BinaryHeap2< key, HeapObject > | Min-heap priority queue realized by a data array |
| ogdf::ListElement< DPoint > | |
| ogdf::ListElement< edge > | |
| ogdf::ListElement< Group > | |
| ogdf::ListElement< IPoint > | |
| ogdf::ListElement< PQNode< edge, IndInfo *, bool > * > | |
| ogdf::ListElement< PQNode< edge, whaInfo *, bool > * > | |
| ogdf::ListElement< PQNode< edge, X, bool > * > | |
| ogdf::ListElement< PQNode< T, whaInfo *, Y > * > | |
| ogdf::ListPure< DPoint > | |
| ogdf::List< DPoint > | |
| ogdf::DPolyline | Polylines with real coordinates |
| ogdf::DPolygon | Polygons with real coordinates |
| ogdf::ListPure< edge > | |
| ogdf::List< edge > | |
| ogdf::ListPure< Group > | |
| ogdf::List< Group > | |
| ogdf::RadialTreeLayout::Grouping | |
| ogdf::ListPure< IPoint > | |
| ogdf::List< IPoint > | |
| ogdf::IPolyline | Polylines with integer coordinates |
| ogdf::ListPure< PQNode< edge, IndInfo *, bool > * > | |
| ogdf::List< PQNode< edge, IndInfo *, bool > * > | |
| ogdf::ListPure< PQNode< edge, whaInfo *, bool > * > | |
| ogdf::List< PQNode< edge, whaInfo *, bool > * > | |
| ogdf::ListPure< PQNode< edge, X, bool > * > | |
| ogdf::List< PQNode< edge, X, bool > * > | |
| ogdf::ListPure< PQNode< T, whaInfo *, Y > * > | |
| ogdf::List< PQNode< T, whaInfo *, Y > * > | |
| ogdf::AcyclicSubgraphModule | Base class of algorithms for computing a maximal acyclic subgraph |
| ogdf::DfsAcyclicSubgraph | DFS-based algorithm for computing a maximal acyclic subgraph |
| ogdf::GreedyCycleRemoval | Greedy algorithm for computing a maximal acyclic subgraph |
| ogdf::AddNodeComparer | Node comparer for sorting by decreasing int values |
| ogdf::AdjacencyOracle | Tells you in linear time if two nodes are adjacent |
| ogdf::AdjEntryArrayBase | Abstract base class for adjacency entry arrays |
| ogdf::AdjEntryArray< T > | Dynamic arrays indexed with adjacency entries |
| ogdf::AnyOption | |
| ogdf::CompressionOption< compressionOption > | |
| ogdf::InterleavingOption< interleavingOption > | |
| ogdf::LinkOption< linkOption > | |
| ogdf::Array< E, INDEX > | The parameterized class Array<E,INDEX> implements dynamic arrays of type E |
| ogdf::ArrayBuffer< E, INDEX > | An array that keeps track of the number of inserted elements; also usable as an efficient stack |
| ogdf::Array2D< E > | The parameterized class Array2D<E> implements dynamic two-dimensional arrays |
| ogdf::AugmentationModule | The base class for graph augmentation algorithms |
| ogdf::DfsMakeBiconnected | Implementation of a DFS-based algorithm for biconnectivity augmentation |
| ogdf::PlanarAugmentation | The algorithm for planar biconnectivity augmentation (Mutzel, Fialko) |
| ogdf::PlanarAugmentationFix | The algorithm for biconnectivity augmentation with fixed combinatorial embedding |
| ogdf::Barrier | Representation of a barrier |
| ogdf::BaseConstraint | Basic constraint type |
| ogdf::ChunkConnection | |
| ogdf::CutConstraint | |
| ogdf::BasicPageRank | Basic page rank calculation |
| ogdf::BCTree | Static BC-trees |
| ogdf::DynamicBCTree | Dynamic BC-trees |
| ogdf::DynamicSPQRForest | Dynamic SPQR-forest |
| ogdf::DynamicSPQRTree | Linear-time implementation of dynamic SPQR-trees |
| ogdf::DynamicPlanarSPQRTree | SPQR-trees of planar graphs |
| ogdf::BendString | |
| ogdf::BinaryHeap< X, Priority, INDEX > | |
| ogdf::BinaryHeap2< key, HeapObject >::HeapEntry | |
| ogdf::BinaryHeap< X, Priority, INDEX >::Element | |
| ogdf::BinaryHeapSimple< X, INDEX > | Dynamically growing binary heap tuned for efficiency on a small interface (compared to BinaryHeap) |
| ogdf::Top10Heap< X, INDEX > | A variant of BinaryHeapSimple which always holds only the X (e.g. X=10) elements with the highest keys |
| ogdf::Top10Heap< Prioritized< X *, Priority >, INDEX > | |
| ogdf::DeletingTop10Heap< X, Priority, STATICCOMPARER, INDEX > | A variant of Top10Heap which deletes the elements that get rejected from the heap |
| ogdf::BoundedQueue< E, INDEX > | The parameterized class BoundedQueue<E,INDEX> implements queues with bounded size |
| ogdf::BoundedStack< E, INDEX > | The parameterized class BoundedStack<E,INDEX> implements stacks with bounded size |
| ogdf::BoyerMyrvoldInit | This class is used in the Boyer-Myrvold planarity test for preprocessing purposes |
| ogdf::BoyerMyrvoldPlanar | This class implements the extended BoyerMyrvold planarity embedding algorithm |
| ogdf::BucketFunc< E > | Abstract base class for bucket functions |
| ogdf::CCLayoutPackModule | Base class of algorithms that arrange/pack layouts of connected components |
| ogdf::TileToRowsCCPacker | The tile-to-rows algorithm for packing drawings of connected components |
| ogdf::CconnectClusterPlanar | |
| ogdf::CconnectClusterPlanarEmbed | |
| ogdf::CliqueFinder | Finds cliques and dense subgraphs |
| ogdf::ClusterArrayBase | Abstract base class for cluster arrays |
| ogdf::ClusterArray< T > | Dynamic arrays indexed with clusters |
| ogdf::ClustererModule | Interface for algorithms that compute a clustering for a given graph |
| ogdf::Clusterer | |
| ogdf::ClusterGraphCopyAttributes | Manages access on copy of an attributed clustered graph |
| ogdf::ClusterGraphObserver | |
| ogdf::ClusterInfo | Stores information associated with a cluster |
| ogdf::ClusterOrthoShaper | |
| ogdf::ClusterPlanarizationLayout | The cluster planarization layout algorithm |
| ogdf::ClusterPlanarizationLayout::ClusterPosition | |
| ogdf::ClusterPQContainer | |
| ogdf::ClusterSet | |
| ogdf::ClusterSetPure | |
| ogdf::ClusterSetSimple | |
| ogdf::CoffmanGrahamRanking::_int_set | |
| ogdf::CoinCallbacks | |
| ogdf::CoinManager | |
| ogdf::CompactionConstraintGraph< ATYPE >::Interval | |
| ogdf::CompactionConstraintGraph< ATYPE >::SegmentComparer | |
| ogdf::ConnectedSubgraph< T > | |
| ogdf::ConstCombinatorialEmbedding | Combinatorial embeddings of planar graphs |
| ogdf::CombinatorialEmbedding | Combinatorial embeddings of planar graphs with modification functionality |
| ogdf::DualGraph | A dual graph including its combinatorial embedding of an embedded graph |
| ogdf::Constraint | |
| ogdf::ConstraintManager | |
| ogdf::ConvexHull | |
| ogdf::CPlanarEdgeInserter | |
| ogdf::CPlanarSubClusteredGraph | Constructs a c-planar subclustered graph of the input on base of a spanning tree |
| ogdf::CPlanarSubClusteredST | Constructs a c-planar subclustered spanning tree of the input by setting edgearray values |
| ogdf::CriticalSection | Representation of a critical section |
| ogdf::CrossingsMatrix | |
| ogdf::DavidsonHarel | The Davidson-Harel approach for drawing graphs |
| ogdf::DefHashFunc< K > | Default hash functions |
| ogdf::DefHashFunc< double > | Specialized default hash function for double |
| ogdf::DefHashFunc< IPoint > | |
| ogdf::DefHashFunc< String > | |
| ogdf::DefHashFunc< void * > | Specialized default hash function for pointer types |
| ogdf::Dijkstra< T > | Dijkstra's single source shortest path algorithm |
| ogdf::DinoLineBuffer | |
| ogdf::DinoLineBufferPosition | |
| ogdf::DinoTools | |
| ogdf::DinoUmlDiagramGraph | |
| ogdf::DinoUmlToGraphConverter | |
| ogdf::DinoXmlParser | |
| ogdf::DinoXmlScanner | |
| ogdf::DisjointSets< Element, linkOption, compressionOption, interleavingOption > | A Union/Find data structure for maintaining disjoint sets |
| ogdf::DLine | Lines with real coordinates |
| ogdf::DSegment | Line segments with real coordinates |
| ogdf::DRect | Rectangles with real coordinates |
| ogdf::DScaler | Scaling between coordinate systems |
| ogdf::DynamicBacktrack | Extracts all possible paths with backtracking using given edges and special constraints |
| ogdf::EdgeArrayBase | Abstract base class for edge arrays |
| ogdf::EdgeArray< T > | Dynamic arrays indexed with edges |
| ogdf::EdgeAttributes | |
| ogdf::EdgeLabel< coordType > | |
| ogdf::EdgeLeg | |
| ogdf::EdgeRouter | |
| ogdf::edgeValue | |
| ogdf::EdgeVar | |
| ogdf::EFreeList< E, next > | Simple implementation of a FreeList which buffers the memory allocation of an embedded list item |
| ogdf::EFreeListIndexPool< E, next, index > | More complex implementation of a FreeList, which is able to generate indeices for the elements |
| ogdf::EFreeListTypes< E, next > | Type declarations for EFreeList |
| ogdf::ELabelInterface< coordType > | |
| ogdf::ELabelPos< coordType > | |
| ogdf::ELabelPos< coordType >::FeatureComparer | |
| ogdf::ELabelPos< coordType >::FeatureInfo | |
| ogdf::ELabelPos< coordType >::FeatureLink | |
| ogdf::ELabelPos< coordType >::LabelInfo | |
| ogdf::ELabelPos< coordType >::PosInfo | |
| ogdf::ELabelPos< coordType >::SegmentInfo | |
| ogdf::ELabelPosSimple | |
| ogdf::EList< L, E, numElem, first, last, next, prev > | The embedded list template |
| ogdf::EListIterator< E, prev, next > | Implementation of an embedded list iterator used by EList |
| ogdf::EmbedderMaxFaceBiconnectedGraphs< T > | Computes an embedding of a biconnected graph with maximum external face |
| ogdf::EmbedderMaxFaceBiconnectedGraphsLayers< T > | Computes an embedding of a biconnected graph with maximum external face (plus layers approach) |
| ogdf::EnergyFunction | The interface for energy functions for the Davidson Harel graph drawing method |
| ogdf::NodePairEnergy | |
| ogdf::Attraction | Energy function for attraction between two adjacent vertices |
| ogdf::Overlap | |
| ogdf::Repulsion | |
| ogdf::Planarity | |
| ogdf::PlanarityGrid | |
| ogdf::ENGLayer | |
| ogdf::EStack< S, E, first, next > | The embedded stack class template |
| ogdf::Exception | Base class of all ogdf exceptions |
| ogdf::AlgorithmFailureException | Exception thrown when an algorithm realizes an internal bug that prevents it from continuing |
| ogdf::DynamicCastFailedException | Exception thrown when result of cast is 0 |
| ogdf::InsufficientMemoryException | Exception thrown when not enough memory is available to execute an algorithm |
| ogdf::LibraryNotSupportedException | Exception thrown when an external library shall be used which is not supported |
| ogdf::NoStdComparerException | Exception thrown when a required standard comparer has not been specialized |
| ogdf::PreconditionViolatedException | Exception thrown when preconditions are violated |
| ogdf::ExternE | List of externally active nodes strictly between x and y for minortypes B and E |
| ogdf::ExtractKuratowskis | Extracts multiple Kuratowski Subdivisions |
| ogdf::FaceArrayBase | Abstract base class for face arrays |
| ogdf::FaceArray< T > | Dynamic arrays indexed with faces of a combinatorial embedding |
| ogdf::FaceSet | Maintains a subset S of the faces contained in an associated combinatorial embedding E |
| ogdf::FaceSetPure | Maintains a subset S of the faces contained in an associated combinatorial embedding E |
| ogdf::FaceSetSimple | Maintains a subset S of the faces contained in an associated combinatorial embedding E |
| ogdf::FindKuratowskis | This class collects information about Kuratowski Subdivisions which is used for extraction later |
| ogdf::FlowCompaction | Compaction algorithm using min-cost flow in the dual of the constraint graph |
| ogdf::FruchtermanReingold | |
| ogdf::GenericPoint< NUMBER > | Parameterized base class for points |
| ogdf::GmlObject | |
| ogdf::GmlParser | |
| ogdf::Graph | Data type for general directed graphs (adjacency list representation) |
| ogdf::CompactionConstraintGraphBase | |
| ogdf::CompactionConstraintGraph< ATYPE > | |
| ogdf::DinoUmlModelGraph | |
| ogdf::EdgeWeightedGraph< T > | |
| ogdf::ExpansionGraph | |
| ogdf::ExtendedNestingGraph | |
| ogdf::FaceSinkGraph | |
| ogdf::GraphCopy | Copies of graphs supporting edge splitting |
| ogdf::EdgeWeightedGraphCopy< T > | |
| ogdf::PlanRep | Planarized representations (of a connected component) of a graph |
| ogdf::ClusterPlanRep | |
| ogdf::PlanRepUML | |
| ogdf::PlanRepInc | |
| ogdf::UpwardPlanRep | Upward planarized representations (of a connected component) of a graph. The upward planarization representation is a single source single sink graph. The single source is s_hat and the single sink is t_hat. s_hat is connected with the sources of the original graph. This muss be done before creating of a instance of UpwardPlanRep. The super sink t_hat is contructed in this class. For technical reason we contruct a sink t and connect the sink of the original graph with t. Then we connect t with t_hat. The edge (t,t_hat) is called the external face handle. Because the right face of the adjEntry of this edge should be the external face |
| ogdf::GraphCopySimple | Copies of graphs with mapping between nodes and edges |
| ogdf::GraphReduction | |
| ogdf::PlanRepExpansion | Planarized representations (of a connected component) of a graph |
| ogdf::GraphAttributes | Stores additional attributes of a graph (like layout information) |
| ogdf::ClusterGraphAttributes | Stores additional attributes of a clustered graph (like layout information) |
| ogdf::UMLGraph | |
| ogdf::GraphConstraints | |
| ogdf::GraphCopyAttributes | |
| ogdf::GraphElement | The base class for objects used by graphs like nodes, edges, etc |
| ogdf::AdjElement | Class for adjacency list elements |
| ogdf::ClusterElement | Representation of clusters in a clustered graph |
| ogdf::EdgeElement | Class for the representation of edges |
| ogdf::FaceElement | Faces in a combinatorial embedding |
| ogdf::NodeElement | Class for the representation of nodes |
| ogdf::GraphListBase | Base class for GraphElement lists |
| ogdf::GraphList< T > | Lists of graph objects (like nodes, edges, etc.) |
| ogdf::GraphObserver | Abstract Base class for classes that need to keep track of changes in the graph like addition/deletion of nodes or edges. derived classes have to overload nodeDeleted, nodeAdded edgeDeleted, edgeAdded these functions should be called by Graph before (delete) |
| ogdf::ClusterGraph | Representation of clustered graphs |
| ogdf::ClusterGraphCopy | |
| ogdf::PlanRepInc | |
| ogdf::GridLayout | Representation of a graph's grid layout |
| ogdf::GridLayoutMapped | |
| ogdf::HashConstIterator< K, I, H > | Iterators for hash tables |
| ogdf::HashElementBase | Base class for elements within a hash table |
| ogdf::HashElement< Tuple2< I1_, I2_ >, E_ > | |
| ogdf::HashElement< K, I > | Representation of elements in a hash table |
| ogdf::HashFuncTuple< K1_, K2_, Hash1_, Hash2_ > | |
| ogdf::HashingBase | Base class for hashing with chaining and table doubling |
| ogdf::Hashing< I, E, H > | |
| ogdf::HashArray< I, E, H > | Indexed arrays using hashing for element access |
| ogdf::Hashing< Tuple2< I1, I2 >, E, HashFuncTuple< I1, I2, H1, H2 > > | |
| ogdf::HashArray2D< I1, I2, E, H1, H2 > | Indexed 2-dimensional arrays using hashing for element access |
| ogdf::Hashing< Tuple2< I1_, I2_ >, E_, HashFuncTuple< I1_, I2_, Hash1_, Hash2_ > > | |
| ogdf::Hashing< K, I, H > | Hashing with chaining and table doubling |
| ogdf::HeapBase< Priority, HeapObject > | |
| ogdf::HeapElement< Score, X > | |
| ogdf::Hierarchy | Representation of proper hierarchies used by Sugiyama-layout |
| ogdf::HierarchyClusterLayoutModule | Interface of hierarchy layout algorithms for cluster graphs |
| ogdf::OptimalHierarchyClusterLayout | The LP-based hierarchy cluster layout algorithm |
| ogdf::HierarchyLayoutModule | Interface of hierarchy layout algorithms |
| ogdf::FastHierarchyLayout | Coordinate assignment phase for the Sugiyama algorithm by Buchheim et al. |
| ogdf::FastSimpleHierarchyLayout | Coordinate assignment phase for the Sugiyama algorithm by Ulrik Brandes and Boris Köpf |
| ogdf::OptimalHierarchyLayout | The LP-based hierarchy layout algorithm |
| ogdf::HyperGraph | |
| ogdf::HyperGraph::AdjElement | Representation of adjacency elements |
| ogdf::HyperGraph::ArrayController< ElementType > | Array controllers manage the graph arrays of an element |
| ogdf::HyperGraph::ArrayControllerTypes< ElementType > | |
| ogdf::HyperGraph::EdgeElement | Representation of hyper edges |
| ogdf::HyperGraph::GraphArrayBase< E > | |
| ogdf::HyperGraph::GraphArray< T, E > | |
| ogdf::HyperGraph::NodeElement | Representation of node elements |
| ogdf::HyperGraphTypes | Type declarations for HyperGraph |
| ogdf::IncNodeInserter | |
| ogdf::SimpleIncNodeInserter | |
| ogdf::IndInfo | |
| ogdf::Initialization | |
| ogdf::InitialPlacer | |
| ogdf::BarycenterPlacer | |
| ogdf::CirclePlacer | |
| ogdf::MedianPlacer | |
| ogdf::RandomPlacer | |
| ogdf::SolarPlacer | |
| ogdf::ZeroPlacer | |
| ogdf::IntersectionRectangle | |
| ogdf::KuratowskiConstraint | |
| ogdf::KuratowskiStructure | A Kuratowski Structure is a special graph structure containing severals subdivisions |
| ogdf::KuratowskiWrapper | Wrapper-class for Kuratowski Subdivisions containing the minortype and edgelist |
| ogdf::LayerBasedUPRLayout::RankComparer | |
| ogdf::Layout | Stores a layout of a graph (coordinates of nodes, bend points of edges) |
| ogdf::LayoutClusterPlanRepModule | Interface for planar cluster layout algorithms |
| ogdf::ClusterOrthoLayout | |
| ogdf::LayoutModule | Interface of general layout algorithms |
| ogdf::BalloonLayout | |
| ogdf::CircularLayout | The circular layout algorithm |
| ogdf::ComponentSplitterLayout | |
| ogdf::DavidsonHarelLayout | The Davidson-Harel layout algorithm |
| ogdf::DominanceLayout | |
| ogdf::FastMultipoleEmbedder | |
| ogdf::FastMultipoleMultilevelEmbedder | |
| ogdf::FMMMLayout | The fast multipole multilevel layout algorithm |
| ogdf::ForceLayoutModule | Interface of general layout algorithms |
| ogdf::SpringEmbedderFRExact | |
| ogdf::GEMLayout | The energy-based GEM layout algorithm |
| ogdf::GridLayoutModule | Base class for grid layout algorithms |
| ogdf::PlanarGridLayoutModule | Base class for planar grid layout algorithms |
| ogdf::FPPLayout | |
| ogdf::GridLayoutPlanRepModule | Base class for grid layout algorithms operating on a PlanRep |
| ogdf::MixedModelLayout | Implementation of the Mixed-Model layout algorithm |
| ogdf::PlanarDrawLayout | Implementation of the Planar-Draw layout algorithm |
| ogdf::PlanarStraightLayout | Implementation of the Planar-Straight layout algorithm |
| ogdf::SchnyderLayout | |
| ogdf::PlanarizationGridLayout | The planarization grid layout algorithm |
| ogdf::MixedForceLayout | |
| ogdf::MMMExampleFastLayout | An example Layout using the Modular Mutlievel Mixer |
| ogdf::MMMExampleNiceLayout | An example Layout using the Modular Mutlievel Mixer |
| ogdf::MMMExampleNoTwistLayout | An example Layout using the Modular Mutlievel Mixer |
| ogdf::ModularMultilevelMixer | Modular multilevel graph layout |
| ogdf::MultilevelLayout | |
| ogdf::MultilevelLayoutModule | Interface of general layout algorithms that also allow a MultilevelGraph as call parameter, extending the interface of a simple LayoutModule |
| ogdf::PreprocessorLayout | The PreprocessorLayout removes multi-edges and self-loops |
| ogdf::ScalingLayout | Scales a Graph relative to the ScalingType |
| ogdf::ProcrustesSubLayout | A simple procrustes analysis implementation |
| ogdf::RadialTreeLayout | The radial tree layout algorithm |
| ogdf::SpringEmbedderFR | The spring-embedder layout algorithm by Fruchterman and Reingold |
| ogdf::SpringEmbedderKK | The spring-embedder layout algorithm by Kamada and Kawai |
| ogdf::StressMajorization | |
| ogdf::SugiyamaLayout | Sugiyama's layout algorithm |
| ogdf::TreeLayout | The tree layout algorithm |
| ogdf::TutteLayout | |
| ogdf::UMLLayoutModule | Interface of UML layout algorithms |
| ogdf::PlanarizationLayout | The planarization layout algorithm |
| ogdf::UpwardPlanarizationLayout | |
| ogdf::VisibilityLayout | |
| ogdf::LayoutPlanRepModule | Interface for planar UML layout algorithms |
| ogdf::OrthoLayout | |
| ogdf::Level | Representation of levels in hierarchies |
| ogdf::LHTreeNode | |
| ogdf::LHTreeNode::Adjacency | |
| ogdf::LHTreeNode::ClusterCrossing | |
| ogdf::ListConstIterator< E > | The parameterized class ListIterator<E> encapsulates a constant pointer to a list element |
| ogdf::ListElement< E > | The parameterized class ListElement<E> represents the structure for elements of doubly linked lists |
| ogdf::ListIterator< E > | The parameterized class ListIterator<E> encapsulates a pointer to a dlist element |
| ogdf::ListPure< E > | The parameterized class ListPure<E> represents doubly linked lists with content type E |
| ogdf::List< E > | The parameterized class ListPure<E> represents doubly linked lists with content type E |
| ogdf::Logger | Centralized global and local logging facility working on streams like cout |
| ogdf::SubgraphPlanarizer | The planarization approach for crossing minimization |
| ogdf::LongestPathCompaction | Compaction algorithm using longest paths in the constraint graph |
| ogdf::LPSolver | |
| ogdf::MallocMemoryAllocator | Implements a simple memory manager using malloc() and free() |
| ogdf::MallocMemoryAllocator::MemElem | |
| ogdf::Master | |
| ogdf::Math | |
| ogdf::MaxPlanarEdgesConstraint | |
| ogdf::MDMFLengthAttribute | |
| ogdf::MinCostFlowModule | Interface for min-cost flow algorithms |
| ogdf::MinCostFlowReinelt | |
| ogdf::MinCostFlowReinelt::arctype | |
| ogdf::MinCostFlowReinelt::nodetype | |
| ogdf::MinCut | |
| ogdf::MinimalClusterConnection | |
| ogdf::MinimumEdgeDistances< ATYPE > | |
| ogdf::MinimumEdgeDistances< ATYPE >::InfoType | |
| ogdf::MinPriorityQueue< Score, X > | |
| ogdf::MixedModelCrossingsBeautifierModule | The base class for Mixed-Model crossings beautifier algorithms |
| ogdf::MMCBBase | Common base class for MMCBDoubleGrid and MMCBLocalStretch |
| ogdf::MMCBDoubleGrid | Crossings beautifier using grid doubling |
| ogdf::MMCBLocalStretch | Crossings beautifier using a local stretch strategy |
| ogdf::MMDummyCrossingsBeautifier | Dummy implementation of Mixed-Model crossings beautifier |
| ogdf::MMVariableEmbeddingInserter::AnchorNodeInfo | |
| ogdf::MMVariableEmbeddingInserter::Paths | |
| ogdf::Module | Base class for modules |
| ogdf::CPlanarSubgraphModule | Interface of algorithms for the computation of c-planar subgraphs |
| ogdf::MaximumCPlanarSubgraph | Exact computation of a maximum c-planar subgraph |
| ogdf::CrossingMinimizationModule | Interface for crossing minimization algorithms |
| ogdf::SubgraphPlanarizer | The planarization approach for crossing minimization |
| ogdf::EdgeInsertionModule | Interface for edge insertion algorithms |
| ogdf::FixedEmbeddingInserter | Edge insertion module that inserts each edge optimally into a fixed embedding |
| ogdf::MultiEdgeApproxInserter | |
| ogdf::VariableEmbeddingInserter | Optimal edge insertion module |
| ogdf::VariableEmbeddingInserter2 | |
| ogdf::EmbedderModule | Base class for embedder algorithms |
| ogdf::EmbedderMaxFace | Planar graph embedding with maximum external face |
| ogdf::EmbedderMaxFaceLayers | Planar graph embedding with maximum external face (plus layers approach) |
| ogdf::EmbedderMinDepth | Planar graph embedding with minimum block-nesting depth |
| ogdf::EmbedderMinDepthMaxFace | Planar graph embedding with minimum block-nesting depth and maximum external face |
| ogdf::EmbedderMinDepthMaxFaceLayers | Planar graph embedding with minimum block-nesting depth and maximum external face (plus layers approach) |
| ogdf::EmbedderMinDepthPiTa | Planar graph embedding with minimum block-nesting depth for given embedded blocks |
| ogdf::SimpleEmbedder | Planar graph embedding by using default planarEmbed |
| ogdf::FeasibleUpwardPlanarSubgraph | |
| ogdf::FixedUpwardEmbeddingInserter | |
| ogdf::FUPSModule | Interface for feasible upward planar subgraph algorithms |
| ogdf::FUPSSimple | |
| ogdf::MMCrossingMinimizationModule | Interface for minor-monotone crossing minimization algorithms |
| ogdf::MMSubgraphPlanarizer | Planarization approach for minor-monotone crossing minimization |
| ogdf::MMEdgeInsertionModule | Interface for minor-monotone edge insertion algorithms |
| ogdf::MMFixedEmbeddingInserter | Minor-monotone edge insertion with fixed embedding |
| ogdf::MMVariableEmbeddingInserter | Minor-monotone edge insertion with variable embedding |
| ogdf::PlanarSubgraphModule | Interface for planar subgraph algorithms |
| ogdf::FastPlanarSubgraph | Computation of a planar subgraph using PQ-trees |
| ogdf::MaximalPlanarSubgraphSimple | |
| ogdf::MaximumPlanarSubgraph | |
| ogdf::UpwardEdgeInserterModule | |
| ogdf::FixedEmbeddingUpwardEdgeInserter | Edge insertion module that inserts each edge optimally into a fixed embedding |
| ogdf::UpwardPlanarizerModule | Interface for upward planarization algorithms |
| ogdf::SubgraphUpwardPlanarizer | |
| ogdf::ModuleOption< M > | The parameterized base class for module options |
| ogdf::MultiEdgeApproxInserter::VertexBlock | |
| ogdf::MultilevelBuilder | |
| ogdf::EdgeCoverMerger | |
| ogdf::IndependentSetMerger | |
| ogdf::LocalBiconnectedMerger | |
| ogdf::MatchingMerger | |
| ogdf::RandomMerger | |
| ogdf::SolarMerger | |
| ogdf::MultilevelGraph | |
| ogdf::NearestRectangleFinder | |
| ogdf::NearestRectangleFinder::PairRectDist | |
| ogdf::NearestRectangleFinder::RectRegion | |
| ogdf::NMM | |
| ogdf::NodeArrayBase | Abstract base class for node arrays |
| ogdf::NodeArray< T > | Dynamic arrays indexed with nodes |
| ogdf::NodeAttributes | |
| ogdf::NodeComparer< sorterType > | |
| ogdf::NodeInfo | |
| ogdf::NodeMerge | |
| ogdf::nodePair | Struct for storing the two corresponding nodes of an edge |
| ogdf::NodePair | |
| ogdf::NodeSet | |
| ogdf::NodeSetPure | |
| ogdf::NodeSetSimple | |
| ogdf::NonPlanarCore | |
| ogdf::Ogml | |
| ogdf::OgmlParser | |
| ogdf::OrderComparer | |
| ogdf::OrthoRep | |
| ogdf::OrthoRep::SideInfoUML | |
| ogdf::OrthoRep::VertexInfoUML | |
| ogdf::OrthoShaper | |
| ogdf::PALabel | Auxiliary class for the planar augmentation algorithm |
| ogdf::ParticleInfo | |
| ogdf::ParticleInfoComparer | |
| ogdf::PertinentGraph | Pertinent graphs of nodes in an SPQR-tree |
| ogdf::Planarity::ChangedCrossing | |
| ogdf::PlanarityModule | Module for planarity testing and planar embeddings |
| ogdf::BoothLueker | Booth-Lueker planarity test |
| ogdf::BoyerMyrvold | Wrapper class used for preprocessing and valid invocation of the planarity test |
| ogdf::PlanRep::Deg1RestoreInfo | Information for restoring degree-1 nodes |
| ogdf::PlanRepExpansion::Crossing | |
| ogdf::PlanRepExpansion::NodeSplit | Representation of a node split in a planarized expansion |
| ogdf::PointComparer | |
| ogdf::PoolMemoryAllocator | The class PoolAllocator represents ogdf's pool memory allocator |
| ogdf::PoolMemoryAllocator::MemElem | |
| ogdf::PoolMemoryAllocator::MemElemEx | |
| ogdf::PQBasicKeyRoot | |
| ogdf::PQBasicKey< T, X, Y > | |
| ogdf::PQInternalKey< T, X, Y > | |
| ogdf::PQLeafKey< T, X, Y > | |
| ogdf::PQNodeKey< T, X, Y > | |
| ogdf::PQLeafKey< edge, X, bool > | |
| ogdf::PlanarLeafKey< X > | |
| ogdf::PQNodeKey< edge, IndInfo *, bool > | |
| ogdf::PQNodeKey< edge, whaInfo *, bool > | |
| ogdf::PQNodeKey< edge, X, bool > | |
| ogdf::PQNodeKey< T, whaInfo *, Y > | |
| ogdf::PQBasicKey< edge, whaInfo *, bool > | |
| ogdf::PQBasicKey< edge, X, bool > | |
| ogdf::PQBasicKey< T, whaInfo *, Y > | |
| ogdf::PQNodeRoot | |
| ogdf::PQNode< T, X, Y > | |
| ogdf::PQInternalNode< T, X, Y > | |
| ogdf::PQLeaf< T, X, Y > | |
| ogdf::PQNode< edge, IndInfo *, bool > | |
| ogdf::EmbedIndicator | |
| ogdf::PQNode< edge, whaInfo *, bool > | |
| ogdf::PQNode< edge, X, bool > | |
| ogdf::PQNode< T, whaInfo *, Y > | |
| ogdf::PQTree< T, X, Y > | |
| ogdf::MaxSequencePQTree< edge, bool > | |
| ogdf::PlanarSubgraphPQTree | |
| ogdf::PreprocessorLayout::EdgeData | Deleted Edges are stored in EdgeData |
| ogdf::Prioritized< X, Priority > | Augments any data elements of type X with keys of type Score |
| ogdf::ProcrustesPointSet | |
| ogdf::QuadTreeNM | |
| ogdf::QuadTreeNodeNM | |
| ogdf::RadialTreeLayout::Group | |
| ogdf::RankingModule | Interface of algorithms for computing a node ranking |
| ogdf::CoffmanGrahamRanking | The coffman graham ranking algorithm |
| ogdf::LongestPathRanking | The longest-path ranking algorithm |
| ogdf::OptimalRanking | The optimal ranking algorithm |
| ogdf::RCCrossings | |
| ogdf::RoutingChannel< ATYPE > | |
| ogdf::RoutingChannel< ATYPE >::vInfo | |
| ogdf::ShellingOrder | The shelling order of a graph |
| ogdf::ShellingOrderModule | Base class for modules that compute a shelling order of a graph |
| ogdf::BiconnectedShellingOrder | Computation of the shelling order for biconnected graphs |
| ogdf::TriconnectedShellingOrder | |
| ogdf::ShortestPathModule | |
| ogdf::ShortestPathWithBFM | |
| ogdf::SimDraw | The Base class for simultaneous graph drawing |
| ogdf::SimDrawColorizer::SimDrawColorScheme | Manages the various color schemes |
| ogdf::SimDrawManipulatorModule | Interface for simdraw manipulators |
| ogdf::SimDrawCaller | Calls modified algorithms for simdraw instances |
| ogdf::SimDrawColorizer | Adds color to a graph |
| ogdf::SimDrawCreator | Creates variety of possible SimDraw creations |
| ogdf::SimDrawCreatorSimple | Offers predefined SimDraw creations |
| ogdf::SimpleCluster | |
| ogdf::Skeleton | Skeleton graphs of nodes in an SPQR-tree |
| ogdf::DynamicSkeleton | Skeleton graphs of nodes in a dynamic SPQR-tree |
| ogdf::StaticSkeleton | Skeleton graphs of nodes in a static SPQR-tree |
| ogdf::Skiplist< X > | A randomized skiplist |
| ogdf::Skiplist< X >::Element | Internal structure to hold the items and internal forward pointers of the skiplist |
| ogdf::SkiplistIterator< X > | Forward-Iterator for Skiplists |
| ogdf::SListConstIterator< E > | The parameterized class SListIterator<E> encapsulates a constant pointer to an slist element |
| ogdf::SListElement< E > | The parameterized class SListElement<E> represents the structure for elements of singly linked lists |
| ogdf::SListIterator< E > | The parameterized class SListIterator<E> encapsulates a pointer to an slist element |
| ogdf::SListPure< E > | The parameterized class SListPure<E> represents singly linked lists with content type E |
| ogdf::QueuePure< E > | The parameterized class QueuePure<E> implements list-based queues |
| ogdf::SList< E > | The parameterized class SList<E> represents singly linked lists with content type E |
| ogdf::Queue< E > | The parameterized class Queue<E> implements list-based queues |
| ogdf::SolarMerger::PathData | |
| ogdf::SPQRTree | Linear-time implementation of static SPQR-trees |
| ogdf::DynamicSPQRTree | Linear-time implementation of dynamic SPQR-trees |
| ogdf::PlanarSPQRTree | SPQR-trees of planar graphs |
| ogdf::DynamicPlanarSPQRTree | SPQR-trees of planar graphs |
| ogdf::StaticPlanarSPQRTree | SPQR-trees of planar graphs |
| ogdf::StaticSPQRTree | Linear-time implementation of static SPQR-trees |
| ogdf::StaticPlanarSPQRTree | SPQR-trees of planar graphs |
| ogdf::SpringEmbedderFRExact::ArrayGraph | |
| ogdf::StackPure< E > | List-based stacks |
| ogdf::Stack< E > | The parameterized class Stack<E> implements list-based stacks |
| ogdf::StackPure< E >::Element | |
| ogdf::StdComparer< E > | Standard comparer (valid as a static comparer) |
| ogdf::StdComparer< bool > | Generates a specialization of the standard static comparer for booleans |
| ogdf::SteinLibParser< T > | Reads a SteinLib file and converts it into a weighted graph and a set of terminal nodes |
| ogdf::String | Representation of character strings |
| ogdf::Sub | |
| ogdf::SubgraphPlanarizer::CrossingStructure | |
| ogdf::System | System specific functionality |
| ogdf::TargetComparer< CONTENTTYPE, STATICCONTENTCOMPARER > | A static comparer which compares the target of pointers ("content"), instead of the pointer's adresses |
| ogdf::Thread | |
| ogdf::Timeouter | Class for timeout funtionality |
| ogdf::CPlanarSubgraphModule | Interface of algorithms for the computation of c-planar subgraphs |
| ogdf::CrossingMinimizationModule | Interface for crossing minimization algorithms |
| ogdf::EdgeInsertionModule | Interface for edge insertion algorithms |
| ogdf::EmbedderModule | Base class for embedder algorithms |
| ogdf::PlanarSubgraphModule | Interface for planar subgraph algorithms |
| ogdf::TopologyModule | |
| ogdf::Tuple2< E1, E2 > | Tuples of two elements (2-tuples) |
| ogdf::Tuple3< E1, E2, E3 > | Tuples of three elements (3-tuples) |
| ogdf::Tuple4< E1, E2, E3, E4 > | Tuples of four elements (4-tuples) |
| ogdf::TwoLayerCrossMin | Interface of two-layer crossing minimization algorithms |
| ogdf::BarycenterHeuristic | The barycenter heuristic for 2-layer crossing minimization |
| ogdf::GreedyInsertHeuristic | The greedy-insert heuristic for 2-layer crossing minimization |
| ogdf::GreedySwitchHeuristic | The greedy-switch heuristic for 2-layer crossing minimization |
| ogdf::MedianHeuristic | The median heuristic for 2-layer crossing minimization |
| ogdf::SiftingHeuristic | The sifting heuristic for 2-layer crossing minimization |
| ogdf::TwoLayerCrossMinSimDraw | |
| ogdf::SplitHeuristic | The split heuristic for 2-layer crossing minimization |
| ogdf::UMLGraph::AssociationClass | |
| ogdf::UMLGraph::CliqueInfo | |
| ogdf::UniformGrid | |
| ogdf::UPRLayoutModule | Interface of hierarchy layout algorithms |
| ogdf::LayerBasedUPRLayout | |
| ogdf::UpwardPlanarModule | |
| ogdf::UpwardPlanarModule::DegreeInfo | |
| ogdf::UpwardPlanarSubgraphModule | Interface for algorithms for computing an upward planar subgraph |
| ogdf::UpwardPlanarSubgraphSimple | |
| ogdf::VComparer< E > | Abstract base class for comparer classes |
| ogdf::VisibilityLayout::EdgeSegment | |
| ogdf::VisibilityLayout::NodeSegment | |
| ogdf::WeightComparer< T > | |
| ogdf::whaInfo | |
| ogdf::WInfo | Saves information about a pertinent node w between two stopping vertices |
| ogdf::XmlAttributeObject | |
| ogdf::XmlObject | |
| ogdf::XmlParser | |
| ogdf::XmlTagObject | |
| ogdf::PQTree< edge, IndInfo *, bool > | |
| ogdf::EmbedPQTree | |
| ogdf::PlanarPQTree | |
| ogdf::PQTree< edge, whaInfo *, bool > | |
| ogdf::PQTree< T, whaInfo *, Y > | |
| ogdf::MaxSequencePQTree< T, Y > | |
| ogdf::Prioritized< X *, Priority > | |
| ogdf::SListElement< PQNode< edge, whaInfo *, bool > * > | |
| ogdf::SListPure< PQNode< edge, whaInfo *, bool > * > | |
| ogdf::Tuple2< I1_, I2_ > | |
| ogdf::VComparer< adjEntry > | |
| ogdf::EdgeComparer | The EdgeComparer compares adjacency entries on base of the position of the nodes given by an Attributed Graph's layout information |
| ogdf::EdgeComparerSimple | |
