/*
* Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
package com.sun.hotspot.igv.hierarchicallayout;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.sun.hotspot.igv.layout.LayoutGraph;
import com.sun.hotspot.igv.layout.LayoutManager;
import com.sun.hotspot.igv.layout.Link;
import com.sun.hotspot.igv.layout.Port;
import com.sun.hotspot.igv.layout.Vertex;
/**
*
* @author Thomas Wuerthinger
*/
public class OldHierarchicalLayoutManager implements LayoutManager {
public static final int DUMMY_WIDTH = 0;
public static final int DUMMY_HEIGHT = 0;
public static final int LAYER_OFFSET = 50;
public static final int OFFSET = 8;
public static final boolean VERTICAL_LAYOUT = true;
public static final boolean ASSERT = false;
public static final boolean TRACE = false;
public static final Timing initTiming = new Timing("init");
public static final Timing removeCyclesTiming = new Timing("removeCycles");
public static final Timing reversedEdgesTiming = new Timing("reversedEdges");
public static final Timing assignLayersTiming = new Timing("assignLayers");
public static final Timing dummyNodesTiming = new Timing("dummyNodes");
public static final Timing crossingReductionTiming = new Timing("crossingReduction");
public static final Timing assignCoordinatesTiming = new Timing("assignCoordinates");
public static final Timing assignRealTiming = new Timing("assignReal");
public static final Timing rootVertexTiming = new Timing("rootVertex");
public static final Timing createEdgesTiming = new Timing("createEdges");
public static final Timing optimizeMedianTiming = new Timing("optimizeMedian");
private Combine combine;
public enum Combine {
NONE,
SAME_INPUTS,
SAME_OUTPUTS
}
private class NodeData {
private Map<Port, Integer> reversePositions;
private Vertex node;
private Link edge;
private int layer;
private int x;
private int y;
private int width;
public NodeData(Vertex node) {
reversePositions = new HashMap<Port, Integer>();
layer = -1;
this.node = node;
assert node != null;
if (VERTICAL_LAYOUT) {
width = node.getSize().width;
} else {
width = node.getSize().height;
}
}
public NodeData(Link edge) {
layer = -1;
this.edge = edge;
assert edge != null;
if (VERTICAL_LAYOUT) {
width = DUMMY_WIDTH;
} else {
width = DUMMY_HEIGHT;
}
}
public Vertex getNode() {
return node;
}
public Link getEdge() {
return edge;
}
public int getCoordinate() {
return x;
}
public void setCoordinate(int x) {
this.x = x;
}
public int getX() {
if (VERTICAL_LAYOUT) {
return x;
} else {
return y;
}
}
public int getY() {
if (VERTICAL_LAYOUT) {
return y;
} else {
return x;
}
}
public void setLayerCoordinate(int y) {
this.y = y;
}
public void setLayer(int x) {
layer = x;
}
public int getLayer() {
return layer;
}
public boolean isDummy() {
return edge != null;
}
public int getWidth() {
return width;
}
public void addReversedStartEdge(Edge<NodeData, EdgeData> e) {
assert e.getData().isReversed();
Port port = e.getData().getEdge().getTo();
int pos = addReversedPort(port);
Point start = e.getData().getRelativeStart();
e.getData().addStartPoint(start);
int yCoord = node.getSize().height + width - node.getSize().width;
e.getData().addStartPoint(new Point(start.x, yCoord));
e.getData().addStartPoint(new Point(pos, yCoord));
e.getData().setRelativeStart(new Point(pos, 0));
}
private int addReversedPort(Port p) {
if (reversePositions.containsKey(p)) {
return reversePositions.get(p);
} else {
width += OFFSET;
reversePositions.put(p, width);
return width;
}
}
public void addReversedEndEdge(Edge<NodeData, EdgeData> e) {
assert e.getData().isReversed();
int pos = addReversedPort(e.getData().getEdge().getFrom());
Point end = e.getData().getRelativeEnd();
e.getData().setRelativeEnd(new Point(pos, node.getSize().height));
int yCoord = 0 - width + node.getSize().width;
e.getData().addEndPoint(new Point(pos, yCoord));
e.getData().addEndPoint(new Point(end.x, yCoord));
e.getData().addEndPoint(end);
}
public int getHeight() {
if (isDummy()) {
if (VERTICAL_LAYOUT) {
return DUMMY_HEIGHT;
} else {
return DUMMY_WIDTH;
}
} else {
if (VERTICAL_LAYOUT) {
return node.getSize().height;
} else {
return node.getSize().width;
}
}
}
@Override
public String toString() {
if (isDummy()) {
return edge.toString() + "(layer=" + layer + ")";
} else {
return node.toString() + "(layer=" + layer + ")";
}
}
}
private class EdgeData {
private Point relativeEnd;
private Point relativeStart;
private List<Point> startPoints;
private List<Point> endPoints;
private boolean important;
private boolean reversed;
private Link edge;
public EdgeData(Link edge) {
this(edge, false);
}
public EdgeData(Link edge, boolean rev) {
this.edge = edge;
reversed = rev;
relativeStart = edge.getFrom().getRelativePosition();
relativeEnd = edge.getTo().getRelativePosition();
assert relativeStart.x >= 0 && relativeStart.x <= edge.getFrom().getVertex().getSize().width;
assert relativeStart.y >= 0 && relativeStart.y <= edge.getFrom().getVertex().getSize().height;
assert relativeEnd.x >= 0 && relativeEnd.x <= edge.getTo().getVertex().getSize().width;
assert relativeEnd.y >= 0 && relativeEnd.y <= edge.getTo().getVertex().getSize().height;
startPoints = new ArrayList<Point>();
endPoints = new ArrayList<Point>();
this.important = true;
}
public boolean isImportant() {
return important;
}
public void setImportant(boolean b) {
this.important = b;
}
public List<Point> getStartPoints() {
return startPoints;
}
public List<Point> getEndPoints() {
return endPoints;
}
public List<Point> getAbsoluteEndPoints() {
if (endPoints.size() == 0) {
return endPoints;
}
List<Point> result = new ArrayList<Point>();
Point point = edge.getTo().getVertex().getPosition();
for (Point p : endPoints) {
Point p2 = new Point(p.x + point.x, p.y + point.y);
result.add(p2);
}
return result;
}
public List<Point> getAbsoluteStartPoints() {
if (startPoints.size() == 0) {
return startPoints;
}
List<Point> result = new ArrayList<Point>();
Point point = edge.getFrom().getVertex().getPosition();
for (Point p : startPoints) {
Point p2 = new Point(p.x + point.x, p.y + point.y);
result.add(p2);
}
return result;
}
public void addEndPoint(Point p) {
endPoints.add(p);
}
public void addStartPoint(Point p) {
startPoints.add(p);
}
public Link getEdge() {
return edge;
}
public void setRelativeEnd(Point p) {
relativeEnd = p;
}
public void setRelativeStart(Point p) {
relativeStart = p;
}
public Point getRelativeEnd() {
return relativeEnd;
}
public Point getRelativeStart() {
return relativeStart;
}
public boolean isReversed() {
return reversed;
}
public void setReversed(boolean b) {
reversed = b;
}
@Override
public String toString() {
return "EdgeData[reversed=" + reversed + "]";
}
}
private Graph<NodeData, EdgeData> graph;
private Map<Vertex, Node<NodeData, EdgeData>> nodeMap;
private int layerOffset;
/** Creates a new instance of HierarchicalPositionManager */
public OldHierarchicalLayoutManager(Combine combine) {
this(combine, LAYER_OFFSET);
}
public OldHierarchicalLayoutManager(Combine combine, int layerOffset) {
this.combine = combine;
this.layerOffset = layerOffset;
}
public void doRouting(LayoutGraph graph) {
}
//public void setPositions(PositionedNode rootNode, List<? extends PositionedNode> nodes, List<? extends PositionedEdge> edges) {
public void doLayout(LayoutGraph layoutGraph) {
doLayout(layoutGraph, new HashSet<Vertex>(), new HashSet<Vertex>());
}
public void doLayout(LayoutGraph layoutGraph, Set<? extends Vertex> firstLayerHint, Set<? extends Vertex> lastLayerHint) {
doLayout(layoutGraph, firstLayerHint, lastLayerHint, new HashSet<Link>());
}
public void doLayout(LayoutGraph layoutGraph, Set<? extends Vertex> firstLayerHint, Set<? extends Vertex> lastLayerHint, Set<? extends Link> importantLinksHint) {
if (TRACE) {
System.out.println("HierarchicalPositionManager.doLayout called");
System.out.println("Vertex count = " + layoutGraph.getVertices().size() + " Link count = " + layoutGraph.getLinks().size());
}
// Nothing to do => quit immediately
if (layoutGraph.getVertices().size() == 0) {
return;
}
initTiming.start();
// Mapping vertex to Node in graph
nodeMap = new HashMap<Vertex, Node<NodeData, EdgeData>>();
graph = new Graph<NodeData, EdgeData>();
Set<Node<NodeData, EdgeData>> rootNodes = new HashSet<Node<NodeData, EdgeData>>();
Set<Vertex> startRootVertices = new HashSet<Vertex>();
for (Vertex v : layoutGraph.getVertices()) {
if (v.isRoot()) {
startRootVertices.add(v);
}
}
rootVertexTiming.start();
Set<Vertex> rootVertices = layoutGraph.findRootVertices(startRootVertices);
rootVertexTiming.stop();
for (Vertex node : layoutGraph.getVertices()) {
NodeData data = new NodeData(node);
Node<NodeData, EdgeData> n = graph.createNode(data, node);
nodeMap.put(node, n);
if (rootVertices.contains(node)) {
rootNodes.add(n);
}
}
Set<? extends Link> links = layoutGraph.getLinks();
Link[] linkArr = new Link[links.size()];
links.toArray(linkArr);
List<Link> linkList = new ArrayList<Link>();
for (Link l : linkArr) {
linkList.add(l);
}
createEdgesTiming.start();
Collections.sort(linkList, new Comparator<Link>() {
public int compare(Link o1, Link o2) {
int result = o1.getFrom().getVertex().compareTo(o2.getFrom().getVertex());
if (result == 0) {
return o1.getTo().getVertex().compareTo(o2.getTo().getVertex());
} else {
return result;
}
}
});
for (Link edge : linkList) {
EdgeData data = new EdgeData(edge);
graph.createEdge(graph.getNode(edge.getFrom().getVertex()), graph.getNode(edge.getTo().getVertex()), data, data);
if (importantLinksHint.size() > 0 && !importantLinksHint.contains(edge)) {
data.setImportant(false);
}
}
createEdgesTiming.stop();
initTiming.stop();
removeCyclesTiming.start();
// STEP 1: Remove cycles!
removeCycles(rootNodes);
if (ASSERT) {
assert checkRemoveCycles();
}
removeCyclesTiming.stop();
reversedEdgesTiming.start();
for (Node<NodeData, EdgeData> n : graph.getNodes()) {
List<Edge<NodeData, EdgeData>> edges = new ArrayList<Edge<NodeData, EdgeData>>(n.getOutEdges());
Collections.sort(edges, new Comparator<Edge<NodeData, EdgeData>>() {
public int compare(Edge<NodeData, EdgeData> o1, Edge<NodeData, EdgeData> o2) {
return o2.getData().getRelativeEnd().x - o1.getData().getRelativeEnd().x;
}
});
for (Edge<NodeData, EdgeData> e : edges) {
if (e.getData().isReversed()) {
e.getSource().getData().addReversedEndEdge(e);
}
}
}
for (Node<NodeData, EdgeData> n : graph.getNodes()) {
List<Edge<NodeData, EdgeData>> edges = new ArrayList<Edge<NodeData, EdgeData>>(n.getInEdges());
Collections.sort(edges, new Comparator<Edge<NodeData, EdgeData>>() {
public int compare(Edge<NodeData, EdgeData> o1, Edge<NodeData, EdgeData> o2) {
return o2.getData().getRelativeStart().x - o1.getData().getRelativeStart().x;
}
});
for (Edge<NodeData, EdgeData> e : edges) {
if (e.getData().isReversed()) {
e.getDest().getData().addReversedStartEdge(e);
}
}
}
reversedEdgesTiming.stop();
assignLayersTiming.start();
// STEP 2: Assign layers!
int maxLayer = assignLayers(rootNodes, firstLayerHint, lastLayerHint);
if (ASSERT) {
assert checkAssignLayers();
}
// Put into layer array
//int maxLayer = 0;
//for(Node<NodeData, EdgeData> n : graph.getNodes()) {
// maxLayer = Math.max(maxLayer, n.getData().getLayer());
//}
ArrayList<Node<NodeData, EdgeData>> layers[] = new ArrayList[maxLayer + 1];
int layerSizes[] = new int[maxLayer + 1];
for (int i = 0; i < maxLayer + 1; i++) {
layers[i] = new ArrayList<Node<NodeData, EdgeData>>();
}
for (Node<NodeData, EdgeData> n : graph.getNodes()) {
int curLayer = n.getData().getLayer();
layers[curLayer].add(n);
}
assignLayersTiming.stop();
// STEP 3: Insert dummy nodes!
dummyNodesTiming.start();
insertDummyNodes(layers);
if (ASSERT) {
assert checkDummyNodes();
}
dummyNodesTiming.stop();
crossingReductionTiming.start();
// STEP 4: Assign Y coordinates
assignLayerCoordinates(layers, layerSizes);
// STEP 5: Crossing reduction
crossingReduction(layers);
crossingReductionTiming.stop();
// STEP 6: Assign Y coordinates
assignCoordinatesTiming.start();
assignCoordinates(layers);
assignCoordinatesTiming.stop();
assignRealTiming.start();
// Assign coordinates of nodes to real objects
for (Node<NodeData, EdgeData> n : graph.getNodes()) {
if (!n.getData().isDummy()) {
Vertex node = n.getData().getNode();
node.setPosition(new Point(n.getData().getX(), n.getData().getY()));
}
}
for (Node<NodeData, EdgeData> n : graph.getNodes()) {
if (!n.getData().isDummy()) {
Vertex node = n.getData().getNode();
List<Edge<NodeData, EdgeData>> outEdges = n.getOutEdges();
for (Edge<NodeData, EdgeData> e : outEdges) {
Node<NodeData, EdgeData> succ = e.getDest();
if (succ.getData().isDummy()) {
//PositionedEdge edge = succ.getData().getEdge();
List<Point> points = new ArrayList<Point>();
assignToRealObjects(layerSizes, succ, points);
} else {
List<Point> points = new ArrayList<Point>();
EdgeData otherEdgeData = e.getData();
points.addAll(otherEdgeData.getAbsoluteStartPoints());
Link otherEdge = otherEdgeData.getEdge();
Point relFrom = new Point(otherEdgeData.getRelativeStart());
Point from = otherEdge.getFrom().getVertex().getPosition();
relFrom.move(relFrom.x + from.x, relFrom.y + from.y);
points.add(relFrom);
Point relTo = new Point(otherEdgeData.getRelativeEnd());
Point to = otherEdge.getTo().getVertex().getPosition();
relTo.move(relTo.x + to.x, relTo.y + to.y);
assert from != null;
assert to != null;
points.add(relTo);
points.addAll(otherEdgeData.getAbsoluteEndPoints());
e.getData().getEdge().setControlPoints(points);
}
}
}
}
assignRealTiming.stop();
initTiming.print();
removeCyclesTiming.print();
reversedEdgesTiming.print();
assignLayersTiming.print();
dummyNodesTiming.print();
crossingReductionTiming.print();
assignCoordinatesTiming.print();
assignRealTiming.print();
rootVertexTiming.print();
createEdgesTiming.print();
optimizeMedianTiming.print();
}
public boolean onOneLine(Point p1, Point p2, Point p3) {
int xoff1 = p1.x - p2.x;
int yoff1 = p1.y - p2.y;
int xoff2 = p3.x - p2.x;
int yoff2 = p3.y - p2.x;
return (xoff1 * yoff2 - yoff1 * xoff2 == 0);
}
private void assignToRealObjects(int layerSizes[], Node<NodeData, EdgeData> cur, List<Point> points) {
assert cur.getData().isDummy();
ArrayList<Point> otherPoints = new ArrayList<Point>(points);
int size = layerSizes[cur.getData().getLayer()];
otherPoints.add(new Point(cur.getData().getX(), cur.getData().getY() - size / 2));
if (otherPoints.size() >= 3 && onOneLine(otherPoints.get(otherPoints.size() - 1), otherPoints.get(otherPoints.size() - 2), otherPoints.get(otherPoints.size() - 3))) {
otherPoints.remove(otherPoints.size() - 2);
}
otherPoints.add(new Point(cur.getData().getX(), cur.getData().getY() + size / 2));
if (otherPoints.size() >= 3 && onOneLine(otherPoints.get(otherPoints.size() - 1), otherPoints.get(otherPoints.size() - 2), otherPoints.get(otherPoints.size() - 3))) {
otherPoints.remove(otherPoints.size() - 2);
}
for (int i = 0; i < cur.getOutEdges().size(); i++) {
Node<NodeData, EdgeData> otherSucc = cur.getOutEdges().get(i).getDest();
if (otherSucc.getData().isDummy()) {
assignToRealObjects(layerSizes, otherSucc, otherPoints);
} else {
EdgeData otherEdgeData = cur.getOutEdges().get(i).getData();
Link otherEdge = otherEdgeData.getEdge();
List<Point> middlePoints = new ArrayList<Point>(otherPoints);
if (cur.getOutEdges().get(i).getData().isReversed()) {
Collections.reverse(middlePoints);
}
ArrayList<Point> copy = new ArrayList<Point>();
Point relFrom = new Point(otherEdgeData.getRelativeStart());
Point from = otherEdge.getFrom().getVertex().getPosition();
//int moveUp = (size - otherEdge.getFrom().getVertex().getSize().height) / 2;
relFrom.move(relFrom.x + from.x, relFrom.y + from.y);
copy.addAll(otherEdgeData.getAbsoluteStartPoints());
copy.add(relFrom);
copy.addAll(middlePoints);
Point relTo = new Point(otherEdgeData.getRelativeEnd());
Point to = otherEdge.getTo().getVertex().getPosition();
relTo.move(relTo.x + to.x, relTo.y + to.y);
copy.add(relTo);
copy.addAll(otherEdgeData.getAbsoluteEndPoints());
otherEdge.setControlPoints(copy);
}
}
}
private boolean checkDummyNodes() {
for (Edge<NodeData, EdgeData> e : graph.getEdges()) {
if (e.getSource().getData().getLayer() != e.getDest().getData().getLayer() - 1) {
return false;
}
}
return true;
}
private void insertDummyNodes(ArrayList<Node<NodeData, EdgeData>> layers[]) {
int sum = 0;
List<Node<NodeData, EdgeData>> nodes = new ArrayList<Node<NodeData, EdgeData>>(graph.getNodes());
int edgeCount = 0;
int innerMostLoop = 0;
for (Node<NodeData, EdgeData> n : nodes) {
List<Edge<NodeData, EdgeData>> edges = new ArrayList<Edge<NodeData, EdgeData>>(n.getOutEdges());
for (Edge<NodeData, EdgeData> e : edges) {
edgeCount++;
Link edge = e.getData().getEdge();
Node<NodeData, EdgeData> destNode = e.getDest();
Node<NodeData, EdgeData> lastNode = n;
Edge<NodeData, EdgeData> lastEdge = e;
boolean searchForNode = (combine != Combine.NONE);
for (int i = n.getData().getLayer() + 1; i < destNode.getData().getLayer(); i++) {
Node<NodeData, EdgeData> foundNode = null;
if (searchForNode) {
for (Node<NodeData, EdgeData> sameLayerNode : layers[i]) {
innerMostLoop++;
if (combine == Combine.SAME_OUTPUTS) {
if (sameLayerNode.getData().isDummy() && sameLayerNode.getData().getEdge().getFrom() == edge.getFrom()) {
foundNode = sameLayerNode;
break;
}
} else if (combine == Combine.SAME_INPUTS) {
if (sameLayerNode.getData().isDummy() && sameLayerNode.getData().getEdge().getTo() == edge.getTo()) {
foundNode = sameLayerNode;
break;
}
}
}
}
if (foundNode == null) {
searchForNode = false;
NodeData intermediateData = new NodeData(edge);
Node<NodeData, EdgeData> curNode = graph.createNode(intermediateData, null);
curNode.getData().setLayer(i);
layers[i].add(0, curNode);
sum++;
lastEdge.remove();
graph.createEdge(lastNode, curNode, e.getData(), null);
assert lastNode.getData().getLayer() == curNode.getData().getLayer() - 1;
lastEdge = graph.createEdge(curNode, destNode, e.getData(), null);
lastNode = curNode;
} else {
lastEdge.remove();
lastEdge = graph.createEdge(foundNode, destNode, e.getData(), null);
lastNode = foundNode;
}
}
}
}
if (TRACE) {
System.out.println("Number of edges: " + edgeCount);
}
if (TRACE) {
System.out.println("Dummy nodes inserted: " + sum);
}
}
private void assignLayerCoordinates(ArrayList<Node<NodeData, EdgeData>> layers[], int layerSizes[]) {
int cur = 0;
for (int i = 0; i < layers.length; i++) {
int maxHeight = 0;
for (Node<NodeData, EdgeData> n : layers[i]) {
maxHeight = Math.max(maxHeight, n.getData().getHeight());
}
layerSizes[i] = maxHeight;
for (Node<NodeData, EdgeData> n : layers[i]) {
int curCoordinate = cur + (maxHeight - n.getData().getHeight()) / 2;
n.getData().setLayerCoordinate(curCoordinate);
}
cur += maxHeight + layerOffset;
}
}
private void assignCoordinates(ArrayList<Node<NodeData, EdgeData>> layers[]) {
// TODO: change this
for (int i = 0; i < layers.length; i++) {
ArrayList<Node<NodeData, EdgeData>> curArray = layers[i];
int curY = 0;
for (Node<NodeData, EdgeData> n : curArray) {
n.getData().setCoordinate(curY);
if (!n.getData().isDummy()) {
curY += n.getData().getWidth();
}
curY += OFFSET;
}
}
int curSol = evaluateSolution();
if (TRACE) {
System.out.println("First coordinate solution found: " + curSol);
}
// Sort to correct order
for (int i = 0; i < layers.length; i++) {
Collections.sort(layers[i], new Comparator<Node<NodeData, EdgeData>>() {
public int compare(Node<NodeData, EdgeData> o1, Node<NodeData, EdgeData> o2) {
if (o2.getData().isDummy()) {
return 1;
} else if (o1.getData().isDummy()) {
return -1;
}
return o2.getInEdges().size() + o2.getOutEdges().size() - o1.getInEdges().size() - o1.getOutEdges().size();
}
});
}
optimizeMedianTiming.start();
for (int i = 0; i < 2; i++) {
optimizeMedian(layers);
curSol = evaluateSolution();
if (TRACE) {
System.out.println("Current coordinate solution found: " + curSol);
}
}
optimizeMedianTiming.stop();
normalizeCoordinate();
}
private void normalizeCoordinate() {
int min = Integer.MAX_VALUE;
for (Node<NodeData, EdgeData> n : graph.getNodes()) {
min = Math.min(min, n.getData().getCoordinate());
}
for (Node<NodeData, EdgeData> n : graph.getNodes()) {
n.getData().setCoordinate(n.getData().getCoordinate() - min);
}
}
private void optimizeMedian(ArrayList<Node<NodeData, EdgeData>> layers[]) {
// Downsweep
for (int i = 1; i < layers.length; i++) {
ArrayList<Node<NodeData, EdgeData>> processingList = layers[i];
ArrayList<Node<NodeData, EdgeData>> alreadyAssigned = new ArrayList<Node<NodeData, EdgeData>>();
for (Node<NodeData, EdgeData> n : processingList) {
ArrayList<Node<NodeData, EdgeData>> preds = new ArrayList<Node<NodeData, EdgeData>>(n.getPredecessors());
int pos = n.getData().getCoordinate();
if (preds.size() > 0) {
Collections.sort(preds, new Comparator<Node<NodeData, EdgeData>>() {
public int compare(Node<NodeData, EdgeData> o1, Node<NodeData, EdgeData> o2) {
return o1.getData().getCoordinate() - o2.getData().getCoordinate();
}
});
if (preds.size() % 2 == 0) {
assert preds.size() >= 2;
pos = (preds.get(preds.size() / 2).getData().getCoordinate() - calcRelativeCoordinate(preds.get(preds.size() / 2), n) + preds.get(preds.size() / 2 - 1).getData().getCoordinate() - calcRelativeCoordinate(preds.get(preds.size() / 2 - 1), n)) / 2;
} else {
assert preds.size() >= 1;
pos = preds.get(preds.size() / 2).getData().getCoordinate() - calcRelativeCoordinate(preds.get(preds.size() / 2), n);
}
}
tryAdding(alreadyAssigned, n, pos);
}
}
// Upsweep
for (int i = layers.length - 2; i >= 0; i--) {
ArrayList<Node<NodeData, EdgeData>> processingList = layers[i];
ArrayList<Node<NodeData, EdgeData>> alreadyAssigned = new ArrayList<Node<NodeData, EdgeData>>();
for (Node<NodeData, EdgeData> n : processingList) {
ArrayList<Node<NodeData, EdgeData>> succs = new ArrayList<Node<NodeData, EdgeData>>(n.getSuccessors());
int pos = n.getData().getCoordinate();
if (succs.size() > 0) {
Collections.sort(succs, new Comparator<Node<NodeData, EdgeData>>() {
public int compare(Node<NodeData, EdgeData> o1, Node<NodeData, EdgeData> o2) {
return o1.getData().getCoordinate() - o2.getData().getCoordinate();
}
});
if (succs.size() % 2 == 0) {
assert succs.size() >= 2;
pos = (succs.get(succs.size() / 2).getData().getCoordinate() - calcRelativeCoordinate(n, succs.get(succs.size() / 2)) + succs.get(succs.size() / 2 - 1).getData().getCoordinate() - calcRelativeCoordinate(n, succs.get(succs.size() / 2 - 1))) / 2;
} else {
assert succs.size() >= 1;
pos = succs.get(succs.size() / 2).getData().getCoordinate() - calcRelativeCoordinate(n, succs.get(succs.size() / 2));
}
}
tryAdding(alreadyAssigned, n, pos);
}
}
}
private int median(ArrayList<Integer> arr) {
assert arr.size() > 0;
Collections.sort(arr);
if (arr.size() % 2 == 0) {
return (arr.get(arr.size() / 2) + arr.get(arr.size() / 2 - 1)) / 2;
} else {
return arr.get(arr.size() / 2);
}
}
private int calcRelativeCoordinate(Node<NodeData, EdgeData> n, Node<NodeData, EdgeData> succ) {
if (n.getData().isDummy() && succ.getData().isDummy()) {
return 0;
}
int pos = 0;
int pos2 = 0;
ArrayList<Integer> coords2 = new ArrayList<Integer>();
ArrayList<Integer> coords = new ArrayList<Integer>();
/*if(!n.getData().isDummy())*/ {
for (Edge<NodeData, EdgeData> e : n.getOutEdges()) {
//System.out.println("reversed: " + e.getData().isReversed());
if (e.getDest() == succ) {
if (e.getData().isReversed()) {
if (!n.getData().isDummy()) {
coords.add(e.getData().getRelativeEnd().x);
}
if (!succ.getData().isDummy()) {
coords2.add(e.getData().getRelativeStart().x);
}
} else {
if (!n.getData().isDummy()) {
coords.add(e.getData().getRelativeStart().x);
}
if (!succ.getData().isDummy()) {
coords2.add(e.getData().getRelativeEnd().x);
}
}
}
}
// assert coords.size() > 0;
if (!n.getData().isDummy()) {
pos = median(coords);
}
if (!succ.getData().isDummy()) {
pos2 = median(coords2);
}
}
//System.out.println("coords=" + coords);
//System.out.println("coords2=" + coords2);
return pos - pos2;
}
private boolean intersect(int v1, int w1, int v2, int w2) {
if (v1 >= v2 && v1 < v2 + w2) {
return true;
}
if (v1 + w1 > v2 && v1 + w1 < v2 + w2) {
return true;
}
if (v1 < v2 && v1 + w1 > v2) {
return true;
}
return false;
}
private boolean intersect(Node<NodeData, EdgeData> n1, Node<NodeData, EdgeData> n2) {
return intersect(n1.getData().getCoordinate(), n1.getData().getWidth() + OFFSET, n2.getData().getCoordinate(), n2.getData().getWidth() + OFFSET);
}
private void tryAdding(List<Node<NodeData, EdgeData>> alreadyAssigned, Node<NodeData, EdgeData> node, int pos) {
boolean doesIntersect = false;
node.getData().setCoordinate(pos);
for (Node<NodeData, EdgeData> n : alreadyAssigned) {
if (n.getData().getCoordinate() + n.getData().getWidth() < pos) {
break;
} else if (intersect(node, n)) {
doesIntersect = true;
break;
}
}
if (!doesIntersect) {
// Everything fine, just place the node
int z = 0;
for (Node<NodeData, EdgeData> n : alreadyAssigned) {
if (pos > n.getData().getCoordinate()) {
break;
}
z++;
}
if (z == -1) {
z = alreadyAssigned.size();
}
if (ASSERT) {
assert !findOverlap(alreadyAssigned, node);
}
alreadyAssigned.add(z, node);
} else {
assert alreadyAssigned.size() > 0;
// Search for alternative location
int minOffset = Integer.MAX_VALUE;
int minIndex = -1;
int minPos = 0;
int w = node.getData().getWidth() + OFFSET;
// Try top-most
minIndex = 0;
minPos = alreadyAssigned.get(0).getData().getCoordinate() + alreadyAssigned.get(0).getData().getWidth() + OFFSET;
minOffset = Math.abs(minPos - pos);
// Try bottom-most
Node<NodeData, EdgeData> lastNode = alreadyAssigned.get(alreadyAssigned.size() - 1);
int lastPos = lastNode.getData().getCoordinate() - w;
int lastOffset = Math.abs(lastPos - pos);
if (lastOffset < minOffset) {
minPos = lastPos;
minOffset = lastOffset;
minIndex = alreadyAssigned.size();
}
// Try between
for (int i = 0; i < alreadyAssigned.size() - 1; i++) {
Node<NodeData, EdgeData> curNode = alreadyAssigned.get(i);
Node<NodeData, EdgeData> nextNode = alreadyAssigned.get(i + 1);
int start = nextNode.getData().getCoordinate() + nextNode.getData().getWidth() + OFFSET;
int end = curNode.getData().getCoordinate() - OFFSET;
int bestPoss = end - node.getData().getWidth();
if (bestPoss < pos && pos - bestPoss > minOffset) {
// No better solution possible => break
break;
}
if (end - start >= node.getData().getWidth()) {
// Node could fit here
int cand1 = start;
int cand2 = end - node.getData().getWidth();
int off1 = Math.abs(cand1 - pos);
int off2 = Math.abs(cand2 - pos);
if (off1 < minOffset) {
minPos = cand1;
minOffset = off1;
minIndex = i + 1;
}
if (off2 < minOffset) {
minPos = cand2;
minOffset = off2;
minIndex = i + 1;
}
}
}
assert minIndex != -1;
node.getData().setCoordinate(minPos);
if (ASSERT) {
assert !findOverlap(alreadyAssigned, node);
}
alreadyAssigned.add(minIndex, node);
}
}
private boolean findOverlap(List<Node<NodeData, EdgeData>> nodes, Node<NodeData, EdgeData> node) {
for (Node<NodeData, EdgeData> n1 : nodes) {
if (intersect(n1, node)) {
return true;
}
}
return false;
}
private int evaluateSolution() {
int sum = 0;
for (Edge<NodeData, EdgeData> e : graph.getEdges()) {
Node<NodeData, EdgeData> source = e.getSource();
Node<NodeData, EdgeData> dest = e.getDest();
int offset = 0;
offset = Math.abs(source.getData().getCoordinate() - dest.getData().getCoordinate());
sum += offset;
}
return sum;
}
private void crossingReduction(ArrayList<Node<NodeData, EdgeData>> layers[]) {
for (int i = 0; i < layers.length - 1; i++) {
ArrayList<Node<NodeData, EdgeData>> curNodes = layers[i];
ArrayList<Node<NodeData, EdgeData>> nextNodes = layers[i + 1];
for (Node<NodeData, EdgeData> n : curNodes) {
for (Node<NodeData, EdgeData> succ : n.getSuccessors()) {
if (ASSERT) {
assert nextNodes.contains(succ);
}
nextNodes.remove(succ);
nextNodes.add(succ);
}
}
}
}
private void removeCycles(Set<Node<NodeData, EdgeData>> rootNodes) {
final List<Edge<NodeData, EdgeData>> reversedEdges = new ArrayList<Edge<NodeData, EdgeData>>();
int removedCount = 0;
int reversedCount = 0;
Graph.DFSTraversalVisitor visitor = graph.new DFSTraversalVisitor() {
@Override
public boolean visitEdge(Edge<NodeData, EdgeData> e, boolean backEdge) {
if (backEdge) {
if (ASSERT) {
assert !reversedEdges.contains(e);
}
reversedEdges.add(e);
e.getData().setReversed(!e.getData().isReversed());
}
return e.getData().isImportant();
}
};
Set<Node<NodeData, EdgeData>> nodes = new HashSet<Node<NodeData, EdgeData>>();
nodes.addAll(rootNodes);
assert nodes.size() > 0;
this.graph.traverseDFS(nodes, visitor);
for (Edge<NodeData, EdgeData> e : reversedEdges) {
if (e.isSelfLoop()) {
e.remove();
removedCount++;
} else {
e.reverse();
reversedCount++;
}
}
}
private boolean checkRemoveCycles() {
return !graph.hasCycles();
}
// Only used by assignLayers
private int maxLayerTemp;
private int assignLayers(Set<Node<NodeData, EdgeData>> rootNodes, Set<? extends Vertex> firstLayerHints,
Set<? extends Vertex> lastLayerHints) {
this.maxLayerTemp = -1;
for (Node<NodeData, EdgeData> n : graph.getNodes()) {
n.getData().setLayer(-1);
}
Graph.BFSTraversalVisitor traverser = graph.new BFSTraversalVisitor() {
@Override
public void visitNode(Node<NodeData, EdgeData> n, int depth) {
if (depth > n.getData().getLayer()) {
n.getData().setLayer(depth);
maxLayerTemp = Math.max(maxLayerTemp, depth);
}
}
};
for (Node<NodeData, EdgeData> n : rootNodes) {
if (n.getData().getLayer() == -1) {
this.graph.traverseBFS(n, traverser, true);
}
}
for (Vertex v : firstLayerHints) {
assert nodeMap.containsKey(v);
nodeMap.get(v).getData().setLayer(0);
}
for (Vertex v : lastLayerHints) {
assert nodeMap.containsKey(v);
nodeMap.get(v).getData().setLayer(maxLayerTemp);
}
return maxLayerTemp;
}
private boolean checkAssignLayers() {
for (Edge<NodeData, EdgeData> e : graph.getEdges()) {
Node<NodeData, EdgeData> source = e.getSource();
Node<NodeData, EdgeData> dest = e.getDest();
if (source.getData().getLayer() >= dest.getData().getLayer()) {
return false;
}
}
int maxLayer = 0;
for (Node<NodeData, EdgeData> n : graph.getNodes()) {
assert n.getData().getLayer() >= 0;
if (n.getData().getLayer() > maxLayer) {
maxLayer = n.getData().getLayer();
}
}
int countPerLayer[] = new int[maxLayer + 1];
for (Node<NodeData, EdgeData> n : graph.getNodes()) {
countPerLayer[n.getData().getLayer()]++;
}
if (TRACE) {
System.out.println("Number of layers: " + maxLayer);
}
return true;
}
}