/**
* Post-process the balanced placement by moving linear segments where obvious improvements can be
* made.
*
* @param layeredGraph the layered graph
*/
private void postProcess(final LGraph layeredGraph) {
// process each linear segment independently
for (LinearSegment segment : linearSegments) {
double minRoomAbove = Integer.MAX_VALUE, minRoomBelow = Integer.MAX_VALUE;
for (LNode node : segment.nodes) {
double roomAbove, roomBelow;
int index = node.getIndex();
// determine the amount by which the linear segment can be moved up without overlap
if (index > 0) {
LNode neighbor = node.getLayer().getNodes().get(index - 1);
float spacing = spacings.getVerticalSpacing(node, neighbor);
roomAbove =
node.getPosition().y
- node.getMargin().top
- (neighbor.getPosition().y
+ neighbor.getSize().y
+ neighbor.getMargin().bottom
+ spacing);
} else {
roomAbove = node.getPosition().y - node.getMargin().top;
}
minRoomAbove = Math.min(roomAbove, minRoomAbove);
// determine the amount by which the linear segment can be moved down without
// overlap
if (index < node.getLayer().getNodes().size() - 1) {
LNode neighbor = node.getLayer().getNodes().get(index + 1);
float spacing = spacings.getVerticalSpacing(node, neighbor);
roomBelow =
neighbor.getPosition().y
- neighbor.getMargin().top
- (node.getPosition().y + node.getSize().y + node.getMargin().bottom + spacing);
} else {
roomBelow = 2 * node.getPosition().y;
}
minRoomBelow = Math.min(roomBelow, minRoomBelow);
}
double minDisplacement = Integer.MAX_VALUE;
boolean foundPlace = false;
// determine the minimal displacement that would make one incoming edge straight
LNode firstNode = segment.nodes.get(0);
for (LPort target : firstNode.getPorts()) {
double pos = firstNode.getPosition().y + target.getPosition().y + target.getAnchor().y;
for (LEdge edge : target.getIncomingEdges()) {
LPort source = edge.getSource();
double d =
source.getNode().getPosition().y
+ source.getPosition().y
+ source.getAnchor().y
- pos;
if (Math.abs(d) < Math.abs(minDisplacement)
&& Math.abs(d) < (d < 0 ? minRoomAbove : minRoomBelow)) {
minDisplacement = d;
foundPlace = true;
}
}
}
// determine the minimal displacement that would make one outgoing edge straight
LNode lastNode = segment.nodes.get(segment.nodes.size() - 1);
for (LPort source : lastNode.getPorts()) {
double pos = lastNode.getPosition().y + source.getPosition().y + source.getAnchor().y;
for (LEdge edge : source.getOutgoingEdges()) {
LPort target = edge.getTarget();
double d =
target.getNode().getPosition().y
+ target.getPosition().y
+ target.getAnchor().y
- pos;
if (Math.abs(d) < Math.abs(minDisplacement)
&& Math.abs(d) < (d < 0 ? minRoomAbove : minRoomBelow)) {
minDisplacement = d;
foundPlace = true;
}
}
}
// if such a displacement could be found, apply it to the whole linear segment
if (foundPlace && minDisplacement != 0) {
for (LNode node : segment.nodes) {
node.getPosition().y += minDisplacement;
}
}
}
}
/**
* Calculate the force acting on the given linear segment. The force is stored in the segment's
* deflection field.
*
* @param segment the linear segment whose force is to be calculated
* @param incoming whether incoming edges should be considered
* @param outgoing whether outgoing edges should be considered
* @param deflectionDampening factor by which deflections are dampened
*/
private void calcDeflection(
final LinearSegment segment,
final boolean incoming,
final boolean outgoing,
final double deflectionDampening) {
double segmentDeflection = 0;
int nodeWeightSum = 0;
for (LNode node : segment.nodes) {
double nodeDeflection = 0;
int edgeWeightSum = 0;
int inputPrio = incoming ? node.getProperty(INPUT_PRIO) : Integer.MIN_VALUE;
int outputPrio = outgoing ? node.getProperty(OUTPUT_PRIO) : Integer.MIN_VALUE;
int minPrio = Math.max(inputPrio, outputPrio);
// Calculate force for every port/edge
for (LPort port : node.getPorts()) {
double portpos = node.getPosition().y + port.getPosition().y + port.getAnchor().y;
if (outgoing) {
for (LEdge edge : port.getOutgoingEdges()) {
LPort otherPort = edge.getTarget();
LNode otherNode = otherPort.getNode();
if (segment != linearSegments[otherNode.id]) {
int otherPrio =
Math.max(otherNode.getProperty(INPUT_PRIO), otherNode.getProperty(OUTPUT_PRIO));
int prio = edge.getProperty(InternalProperties.PRIORITY);
if (prio >= minPrio && prio >= otherPrio) {
nodeDeflection +=
otherNode.getPosition().y
+ otherPort.getPosition().y
+ otherPort.getAnchor().y
- portpos;
edgeWeightSum++;
}
}
}
}
if (incoming) {
for (LEdge edge : port.getIncomingEdges()) {
LPort otherPort = edge.getSource();
LNode otherNode = otherPort.getNode();
if (segment != linearSegments[otherNode.id]) {
int otherPrio =
Math.max(otherNode.getProperty(INPUT_PRIO), otherNode.getProperty(OUTPUT_PRIO));
int prio = edge.getProperty(InternalProperties.PRIORITY);
if (prio >= minPrio && prio >= otherPrio) {
nodeDeflection +=
otherNode.getPosition().y
+ otherPort.getPosition().y
+ otherPort.getAnchor().y
- portpos;
edgeWeightSum++;
}
}
}
}
}
// Avoid division by zero
if (edgeWeightSum > 0) {
segmentDeflection += nodeDeflection / edgeWeightSum;
nodeWeightSum++;
}
}
if (nodeWeightSum > 0) {
segment.deflection = deflectionDampening * segmentDeflection / nodeWeightSum;
segment.weight = nodeWeightSum;
} else {
segment.deflection = 0;
segment.weight = 0;
}
}