/** * Creates an unbalanced placement for the sorted linear segments. * * @param layeredGraph the layered graph to create an unbalanced placement for. */ private void createUnbalancedPlacement(final LGraph layeredGraph) { // How many nodes are currently placed in each layer int[] nodeCount = new int[layeredGraph.getLayers().size()]; // The type of the node most recently placed in a given layer NodeType[] recentNodeType = new NodeType[layeredGraph.getLayers().size()]; // Iterate through the linear segments (in proper order!) and place them for (LinearSegment segment : linearSegments) { // Determine the uppermost placement for the linear segment double uppermostPlace = 0.0f; for (LNode node : segment.nodes) { NodeType nodeType = node.getType(); int layerIndex = node.getLayer().getIndex(); nodeCount[layerIndex]++; // Calculate how much space to leave between the linear segment and the last // node of the given layer float spacing = spacings.edgeEdgeSpacing * spacings.inLayerSpacingFactor; if (nodeCount[layerIndex] > 0) { if (recentNodeType[layerIndex] != null) { spacing = spacings.getVerticalSpacing(recentNodeType[layerIndex], nodeType); } } uppermostPlace = Math.max(uppermostPlace, node.getLayer().getSize().y + spacing); } // Apply the uppermost placement to all elements for (LNode node : segment.nodes) { // Set the node position node.getPosition().y = uppermostPlace + node.getMargin().top; // Adjust layer size Layer layer = node.getLayer(); layer.getSize().y = uppermostPlace + node.getMargin().top + node.getSize().y + node.getMargin().bottom; recentNodeType[layer.getIndex()] = node.getType(); } } }
/** * 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; } } } }
/** * Put a node into the given linear segment and check for following parts of a long edge. * * @param node the node to put into the linear segment * @param segment a linear segment * @return {@code true} if the given node was not already part of another segment and was thus * added to the given segment. */ private boolean fillSegment(final LNode node, final LinearSegment segment) { NodeType nodeType = node.getType(); // handle initial big nodes as big node type if (node.getProperty(InternalProperties.BIG_NODE_INITIAL)) { nodeType = NodeType.BIG_NODE; } if (node.id >= 0) { // The node is already part of another linear segment return false; } else if (segment.nodeType != null && (nodeType == NodeType.BIG_NODE && nodeType != segment.nodeType)) { // Big nodes are not allowed to share a linear segment with other dummy nodes return false; } else { // Add the node to the given linear segment node.id = segment.id; segment.nodes.add(node); } segment.nodeType = nodeType; if (nodeType == NodeType.LONG_EDGE || nodeType == NodeType.NORTH_SOUTH_PORT || nodeType == NodeType.BIG_NODE) { // This is a LONG_EDGE, NORTH_SOUTH_PORT or BIG_NODE dummy; check if any of its // successors are of one of these types too. If so, we can form a linear segment // with one of them. (not with more than one, though) // Note 1: LONG_EDGES and NORTH_SOUTH_PORTs can share a common linear segment // Note 2: we must take care not to make a segment out of nodes that are in the same layer // Note 3: for BIG_NODEs also the first BIG_NODE_INITIAL which is no actual dummy node has // to be considered here for (LPort sourcePort : node.getPorts()) { for (LPort targetPort : sourcePort.getSuccessorPorts()) { LNode targetNode = targetPort.getNode(); NodeType targetNodeType = targetNode.getType(); if (node.getLayer() != targetNode.getLayer()) { if (nodeType == NodeType.BIG_NODE) { // current AND the next node are BIG_NODE dummies if (targetNodeType == NodeType.BIG_NODE) { if (fillSegment(targetNode, segment)) { // We just added another node to this node's linear segment. // That's quite enough. return true; } } } else { // current no bignode and next node is LONG_EDGE and NORTH_SOUTH_PORT if (targetNodeType == NodeType.LONG_EDGE || targetNodeType == NodeType.NORTH_SOUTH_PORT) { if (fillSegment(targetNode, segment)) { // We just added another node to this node's linear segment. // That's quite enough. return true; } } } } } } } return true; }