/** {@inheritDoc} */
public void process(final LGraph layeredGraph, final IElkProgressMonitor monitor) {
monitor.begin("End label placement", 1);
double labelSpacing = layeredGraph.getProperty(LayeredOptions.SPACING_EDGE_LABEL);
// Initialize the offset maps
northOffset = Maps.newHashMap();
southOffset = Maps.newHashMap();
portLabelOffsetHint = Maps.newHashMap();
for (Layer layer : layeredGraph.getLayers()) {
for (LNode node : layer.getNodes()) {
for (LEdge edge : node.getOutgoingEdges()) {
for (LLabel label : edge.getLabels()) {
// Only consider end labels
if (label.getProperty(LayeredOptions.EDGE_LABELS_PLACEMENT) == EdgeLabelPlacement.TAIL
|| label.getProperty(LayeredOptions.EDGE_LABELS_PLACEMENT)
== EdgeLabelPlacement.HEAD) {
placeEndLabel(node, edge, label, labelSpacing);
}
}
}
}
}
monitor.done();
}
/** {@inheritDoc} */
public void process(final LGraph layeredGraph, final IElkProgressMonitor monitor) {
monitor.begin("Linear segments node placement", 1);
spacings = layeredGraph.getProperty(InternalProperties.SPACINGS);
// sort the linear segments of the layered graph
sortLinearSegments(layeredGraph);
// create an unbalanced placement from the sorted segments
createUnbalancedPlacement(layeredGraph);
// balance the placement
balancePlacement(layeredGraph);
// post-process the placement for small corrections
postProcess(layeredGraph);
// release the created resources
linearSegments = null;
spacings = null;
monitor.done();
}
/** {@inheritDoc} */
public void process(final LGraph graph, final IElkProgressMonitor progressMonitor) {
progressMonitor.begin("Greedy switch crossing reduction", 1);
greedySwitchType = graph.getProperty(Properties.GREEDY_SWITCH_TYPE);
int layerCount = graph.getLayers().size();
if (layerCount < 2 || greedySwitchType == GreedySwitchType.OFF) {
progressMonitor.done();
return;
}
initialize(graph);
if (greedySwitchType.useBestOfUpOrDown()) {
compareSweepingUpwardOrDownward();
} else {
sweepOneSidedOrTwoSided();
}
setAsGraph(bestNodeOrder);
progressMonitor.done();
}
/** {@inheritDoc} */
public void process(final LGraph layeredGraph, final IElkProgressMonitor monitor) {
monitor.begin("Spline SelfLoop positioning", 1);
/** Stores which loop placement strategy to choose. */
final SelfLoopPlacement loopPlacement =
layeredGraph.getProperty(Properties.SPLINE_SELF_LOOP_PLACEMENT);
////////////////////////////////////////////////////////
// There are two main jobs to be done:
// 1) Find a loop-side for each component.
// 2) Position ports in the correct order around the node.
////////////////////////////////////////////////////////
// Process all nodes on all layers.
for (final Layer layer : layeredGraph) {
for (final LNode node : layer) {
// Read self-loops components.
final List<ConnectedSelfLoopComponent> components =
node.getProperty(InternalProperties.SPLINE_SELFLOOP_COMPONENTS);
// Components to be distributed by the placement strategy.
final List<ConnectedSelfLoopComponent> componentsToBePlaced = Lists.newArrayList();
for (final ConnectedSelfLoopComponent component : components) {
// Re-Add all hidden edges to their ports.
component.unhideEdges();
if (component.getConstrainedPorts().isEmpty()) {
// If there is no constraint on any port, we have to process this component later
componentsToBePlaced.add(component);
} else {
// If there is at least one port with a constraint to it's port-side,
// we will set the port- and loop-sides by this constraint. (Job 1)
setPortSideByConstraint(component);
if (!component.getNonLoopPorts().isEmpty()) {
// Position and re-add all ports to the node, that are part of a component
// with at least one non-loop edge. (Job 2)
addComponentWithNonLoopEdges(component);
}
}
}
// Now we have to find a loop-side (job 1) for the remaining components. They are all
// stored in componentsToBePlaced. All these components don't have a port with a
// constraint on it's portSide, so we can arrange them accordingly to the cosen strategy.
switch (loopPlacement) {
case EQUALLY_DISTRIBUTED:
setPortSideSpreadEqually(componentsToBePlaced, node);
break;
case NORTH_SEQUENCE:
for (final ConnectedSelfLoopComponent component : componentsToBePlaced) {
component.setLoopSide(LoopSide.N, true);
}
break;
case NORTH_STACKED:
for (final ConnectedSelfLoopComponent component : componentsToBePlaced) {
component.setLoopSide(LoopSide.N, true);
}
break;
default:
// Unknown strategy chosen.
assert false;
break;
}
// Position and re-add all ports to the node.
// This is job 2)
switch (loopPlacement) {
case EQUALLY_DISTRIBUTED:
case NORTH_STACKED:
portStackedPositioning(components);
break;
case NORTH_SEQUENCE:
portLinedPositioning(components);
break;
default:
break;
}
}
}
monitor.done();
}