Uses of Class
de.cau.cs.kieler.core.alg.AbstractAlgorithm

Packages that use AbstractAlgorithm
de.cau.cs.kieler.kiml.util.alg Algorithms for the KIML utility classes. 
de.cau.cs.kieler.klay.force Base package of the force layouter. 
de.cau.cs.kieler.klay.force.model Force model of the KLay Force layout algorithm. 
de.cau.cs.kieler.klay.layered.intermediate Intermediate layout processors. 
de.cau.cs.kieler.klay.layered.p1cycles Phase 1 - cycle breaking by edge reversal. 
de.cau.cs.kieler.klay.layered.p2layers Phase 2 - layer assignment. 
de.cau.cs.kieler.klay.layered.p3order Phase 3 - crossing minimization by node reordering. 
de.cau.cs.kieler.klay.layered.p4nodes Phase 4 - vertical node placement. 
de.cau.cs.kieler.klay.layered.p5edges Phase 5 - edge routing and horizontal node placement. 
de.cau.cs.kieler.klodd.hierarchical Base package of the hierarchical dataflow layout algorithm. 
de.cau.cs.kieler.klodd.hierarchical.impl Implementation of the hierarchical dataflow layout algorithm. 
de.cau.cs.kieler.klodd.hierarchical.structures.slimgraph.alg Algorithms for the slim graph data structure. 
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.kiml.util.alg
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.kiml.util.alg
 class BoxPlacer
          Placing algorithm for boxes.
 class BoxSorter
          Algorithm that sorts nodes according to their priority and size or position.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klay.force
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klay.force
 class ComponentsProcessor
          A processor that is able to split an input graph into connected components and to pack those components after layout.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klay.force.model
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klay.force.model
 class AbstractForceModel
          Superclass for force models.
 class EadesModel
          A force model after the Eades approach.
 class FruchtermanReingoldModel
          A force model after the Fruchterman-Reingold approach.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.intermediate
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.intermediate
 class BigNodesProcessor
          The main class of the big node handler component.
 class CommentPostprocessor
          Post-processor for comment boxes.
 class CommentPreprocessor
          A pre-processor for comment boxes.
 class CompoundCycleProcessor
          Detects cyclic dependencies between compound nodes and reverts edges to remove them before simple cycle removal and layering.
 class CompoundDummyEdgeRemover
          Removes dummy edges that were inserted while importing compound graphs to implement constraints for the layering phase (keep dummy nodes representing subgraph borders left resp.
 class CompoundGraphRestorer
          Removes all dummy edges and dummy nodes apart from upper compound border dummies from the LayeredGraph.
 class CompoundSideProcessor
          Sets up dummy nodes at the sides of a compound node, connects these nodes with dummy edges.
 class EdgeAndLayerConstraintEdgeReverser
          Makes sure nodes with edge or layer constraints have only incoming or only outgoing edges, as appropriate.
 class GraphTransformer
          A layout processor that is able to perform transformations on the coordinates of a graph.
 class HierarchicalPortConstraintProcessor
          Processes constraints imposed on hierarchical node dummies.
 class HierarchicalPortDummySizeProcessor
          Sets the width of hierarchical port dummies.
 class HierarchicalPortOrthogonalEdgeRouter
          This processor does the job of routing edges connected to hierarchical ports.
 class HierarchicalPortPositionProcessor
          Sets the y coordinate of external node dummies representing eastern or western hierarchical ports.
 class HyperedgeDummyMerger
          Looks for long edge dummy nodes that can be joined together.
 class HypernodesProcessor
          Improves the placement of hypernodes by moving them such that they replace the join points of connected edges.
 class InLayerConstraintProcessor
          Makes sure that in-layer constraints are respected.
 class InvertedPortProcessor
          Inserts dummy nodes to cope with inverted ports.
 class LayerConstraintProcessor
          Moves nodes with layer constraints to the appropriate layers.
 class LongEdgeJoiner
          Removes dummy nodes due to edge splitting.
 class LongEdgeSplitter
          Splits the long edges of the layered graph to obtain a proper layering.
 class NodeMarginCalculator
          Sets the node margins.
 class NorthSouthPortPostprocessor
          Removes dummy nodes created by NorthSouthPortPreprocessor and routes the edges properly.
 class NorthSouthPortPreprocessor
          Inserts dummy nodes to cope with northern and southern ports.
 class PortListSorter
          Sorts the port lists of nodes with fixed port orders.
 class PortPositionProcessor
          Determines the actual positions of ports for nodes whose port positions are left to be determined.
 class PortSideProcessor
          Makes sure ports have at least a fixed side.
 class ReversedEdgeRestorer
          Restores the direction of reversed edges.
 class SelfLoopProcessor
          This processor does some work to ensure that other phases and processors can handle self-loops correctly.
 class SubgraphOrderingProcessor
          Postprocesses the node ordering phase to ensure that subgraphs are not intertwined across the layers.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.p1cycles
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.p1cycles
 class GreedyCycleBreaker
          Cycle breaker implementation that uses a greedy algorithm.
 class InteractiveCycleBreaker
          A cycle breaker that responds to user interaction by respecting the direction of edges as given in the original drawing.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.p2layers
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.p2layers
 class InteractiveLayerer
          A node layerer that allows user interaction by respecting previous node positions.
 class LongestPathLayerer
          The most basic layering algorithm, which assign layers according to the longest path to a sink.
 class NetworkSimplexLayerer
          The main class of the network simplex layerer component.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.p3order
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.p3order
 class AbstractCrossingMinimizer
          Abstract superclass for crossing minimizer implementations.
 class InteractiveCrossingMinimizer
          A crossing minimizer that allows user interaction by respecting previous node positions.
 class LayerSweepCrossingMinimizer
          Crossing minimization module that performs one or more sweeps over the layers while applying a two-layer crossing minimization heuristic on each pair of layers.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.p4nodes
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.p4nodes
 class LinearSegmentsNodePlacer
          Node placement implementation that aligns long edges using linear segments.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.p5edges
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klay.layered.p5edges
 class OrthogonalEdgeRouter
          Edge routing implementation that creates orthogonal bend points.
 class PolylineEdgeRouter
          Edge router module that draws edges with non-orthogonal line segments.
 class SplineEdgeRouter
          Implements a naive way of routing the edges with splines.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klodd.hierarchical
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klodd.hierarchical
 class GraphConverter
          Class that converts a KGraph into a slim graph.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klodd.hierarchical.impl
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klodd.hierarchical.impl
 class BalancingLayerAssigner
          Layer assigner that balances the output of a basic layer assigner.
 class BalancingNodePlacer
          Node placing algorithm that improves the overall balance of the graph after executing a basic node placer.
 class BarycenterCrossingReducer
          Implementation of the barycenter method for the 2-layer crossing reduction problem.
 class BasicNodePlacer
          Node placing algorithm that orders all linear segments and creates an unbalanced placement.
 class InteractiveCrossingReducer
           
 class LayerSweepCrossingReducer
          Implementation of a crossing reducer that performs a layer-by-layer sweep with a 2-layer crossing reducer.
 class LongestPathLayerAssigner
          Layer assigner working with the longest path layering algorithm.
 class RectilinearEdgeRouter
          Edge routing algorithm that makes rectilinear edges.
 class SortingLayerwiseEdgePlacer
          Layerwise edge placer implementation that sorts the edges and gives them slot ranks according to the result.
 class SortingNodewiseEdgePlacer
          Nodewise edge placer implementation that sorts the edges and gives them slot ranks according to the result.
 class ToponumLayerwiseEdgePlacer
          Layerwise edge placer implementation that orders routing slots using topological numbering.
 

Uses of AbstractAlgorithm in de.cau.cs.kieler.klodd.hierarchical.structures.slimgraph.alg
 

Subclasses of AbstractAlgorithm in de.cau.cs.kieler.klodd.hierarchical.structures.slimgraph.alg
 class AbstractCycleRemover
          Abstract superclass that can be used for implementations of cycle remover algorithms which operate by reversing edges.
 class DFSCycleRemover
          Cycle remover that uses a depth first search to remove cycles.
 class GreedyCycleRemover
          Cycle remover implementation that uses a greedy algorithm.
 class InteractiveCycleRemover
          A cycle remover that allows interactive layout by considering the node positions given by the user.