Uses of Interface
de.cau.cs.kieler.core.alg.IAlgorithm

Packages that use IAlgorithm
de.cau.cs.kieler.core.alg Basic API for algorithms and their implementations following the strategy design pattern. 
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 Base package of the layered layouter. 
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.modules Definition of the different modules used by the hierarchical dataflow layout algorithm. 
de.cau.cs.kieler.klodd.hierarchical.structures.slimgraph.alg Algorithms for the slim graph data structure. 
 

Uses of IAlgorithm in de.cau.cs.kieler.core.alg
 

Classes in de.cau.cs.kieler.core.alg that implement IAlgorithm
 class AbstractAlgorithm
          Superclass for algorithms used in the KIELER project.
 

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

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

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

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

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

Classes in de.cau.cs.kieler.klay.force.model that implement IAlgorithm
 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 IAlgorithm in de.cau.cs.kieler.klay.layered
 

Subinterfaces of IAlgorithm in de.cau.cs.kieler.klay.layered
 interface ILayoutPhase
          A layout phase is a special kind of layout processor that encapsulates an implementation of one of the algorithm's five main phases.
 interface ILayoutProcessor
          A layout processor processes a LayeredGraph, performing layout related tasks on it.
 

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

Classes in de.cau.cs.kieler.klay.layered.intermediate that implement IAlgorithm
 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 IAlgorithm in de.cau.cs.kieler.klay.layered.p1cycles
 

Classes in de.cau.cs.kieler.klay.layered.p1cycles that implement IAlgorithm
 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 IAlgorithm in de.cau.cs.kieler.klay.layered.p2layers
 

Classes in de.cau.cs.kieler.klay.layered.p2layers that implement IAlgorithm
 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 IAlgorithm in de.cau.cs.kieler.klay.layered.p3order
 

Classes in de.cau.cs.kieler.klay.layered.p3order that implement IAlgorithm
 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 IAlgorithm in de.cau.cs.kieler.klay.layered.p4nodes
 

Classes in de.cau.cs.kieler.klay.layered.p4nodes that implement IAlgorithm
 class LinearSegmentsNodePlacer
          Node placement implementation that aligns long edges using linear segments.
 

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

Classes in de.cau.cs.kieler.klay.layered.p5edges that implement IAlgorithm
 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 IAlgorithm in de.cau.cs.kieler.klodd.hierarchical
 

Classes in de.cau.cs.kieler.klodd.hierarchical that implement IAlgorithm
 class GraphConverter
          Class that converts a KGraph into a slim graph.
 

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

Classes in de.cau.cs.kieler.klodd.hierarchical.impl that implement IAlgorithm
 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 IAlgorithm in de.cau.cs.kieler.klodd.hierarchical.modules
 

Subinterfaces of IAlgorithm in de.cau.cs.kieler.klodd.hierarchical.modules
 interface ICrossingReducer
          Interface for algorithms that reduce crossings in a layered graph.
 interface IEdgeRouter
          Interface for algorithms that route edges in a layered graph.
 interface ILayerAssigner
          Interface for algorithms that assign layers to each node of a graph.
 interface ILayerwiseEdgePlacer
          Interface for algorithms that calculate routing slots for connections going from a layer to the subsequent one.
 interface INodePlacer
          Interface for algorithms that determine a placement for each node in a layered graph.
 interface INodewiseEdgePlacer
          Interface for algorithms that calculate routing slots for connections starting and ending at regular nodes.
 interface ISingleLayerCrossingReducer
          Interface for algorithms that offer heuristics for the 2-layer and 3-layer crossing reduction problem.
 

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

Subinterfaces of IAlgorithm in de.cau.cs.kieler.klodd.hierarchical.structures.slimgraph.alg
 interface ICycleRemover
          Interface for algorithms for removal of cycles in a layout graph.
 

Classes in de.cau.cs.kieler.klodd.hierarchical.structures.slimgraph.alg that implement IAlgorithm
 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.