private int getLayerNumber(final String vertex, final List<GraphLayer> layers) { final GraphLayer layer = layers .stream() .filter(l -> l.getVertices().stream().anyMatch(v -> Objects.equals(v.getId(), vertex))) .findFirst() .orElseThrow(() -> new NoSuchElementException("Can not found the layer of the vertex.")); return layer.getLevel(); } }
private void addToLayer(final Vertex vertex, final int height) { for (int i = this.graph.getLayers().size(); i < height; i++) { this.graph.getLayers().add(0, new GraphLayerImpl()); } final int level = this.graph.getLayers().size() - height; final GraphLayer layer = this.graph.getLayers().get(level); layer.setLevel(height); layer.addVertex(vertex); vertexHeight.put(vertex.getId(), height); } }
private List<GraphLayer> clone(final List<GraphLayer> input) { final ArrayList<GraphLayer> clone = new ArrayList<>(input.size()); for (final GraphLayer value : input) { clone.add(value.clone()); } return clone; }
private void removeVirtualVerticesFromLayers(final List<GraphLayer> layers, final Set<Vertex> vertices) { final Set<String> ids = vertices.stream().map(Vertex::getId).collect(Collectors.toSet()); for (final GraphLayer layer : layers) { for (int i = 0; i < layer.getVertices().size(); i++) { final Vertex existingVertex = layer.getVertices().get(i); if (!ids.contains(existingVertex.getId())) { layer.getVertices().remove(existingVertex); i--; } } } }
private boolean doTranspose(final GraphLayer current, final GraphLayer previous, final List<OrientedEdge> edges) { final List<Vertex> vertices = current.getVertices(); boolean improved = false; for (int i = 1; i < vertices.size(); i++) { final int currentCrossing = this.crossingCount.crossing(edges, previous, current); Collections.swap(vertices, i, i - 1); final int newCrossing = this.crossingCount.crossing(edges, previous, current); if (newCrossing >= currentCrossing) { Collections.swap(vertices, i - 1, i); } else { improved = true; } } return improved; } }
private int distributeVertices(final List<GraphLayer> layers, final HashMap<Integer, Integer> layersStartX, final int y, final int i) { final GraphLayer layer = layers.get(i); int x = layersStartX.get(i); for (final Vertex v : layer.getVertices()) { v.setX(x); v.setY(y); x += DEFAULT_VERTEX_SPACE; x += DEFAULT_VERTEX_WIDTH; } return y + DEFAULT_LAYER_SPACE; }
private static void match(final String[] expected, final GraphLayer layer) { Assertions.assertThat(layer.getVertices()) .as("kie.wb.common.graph.layout.Layer " + layer.getLevel() + " contains " + expected.length + " vertices") .hasSize(expected.length); Assertions.assertThat(layer.getVertices()) .as("kie.wb.common.graph.layout.Layer " + layer.getLevel() + " contains all expected vertices") .extracting(Vertex::getId) .containsOnly(expected); } }
private Object[] flat(final List<OrientedEdge> edges, final GraphLayer north, final GraphLayer south) { final ArrayList<String> southPos = new ArrayList<>(south.getVertices().size()); for (int i = 0; i < south.getVertices().size(); i++) { southPos.add(south.getVertices().get(i).getId()); } return north.getVertices().stream().flatMap(v -> { List<OrientedEdge> connectedEdges = edges.stream() .filter(e -> (e.getToVertexId().equals(v.getId()) || e.getFromVertexId().equals(v.getId()))) .collect(Collectors.toList()); return connectedEdges.stream().map(e -> { if (southPos.contains(e.getToVertexId())) { return southPos.indexOf(e.getToVertexId()); } return southPos.indexOf(e.getFromVertexId()); }).sorted(); }).toArray(); } }
for (int i = 0; i < layers.size(); i++) { final GraphLayer layer = layers.get(i); int currentWidth = layer.getVertices().size() * DEFAULT_VERTEX_WIDTH; currentWidth += (layer.getVertices().size() - 1) * DEFAULT_VERTEX_SPACE; layersWidth.put(i, currentWidth); largestWidth = Math.max(largestWidth, currentWidth);
while (firstIndex < south.getVertices().size()) { firstIndex <<= 1;
final List<OrientedEdge> edges) { final List<Integer> connectedVerticesIndex = new ArrayList<>(); final List<Vertex> vertices = layer.getVertices(); for (int i = 0; i < vertices.size(); i++) { final Vertex vertexInLayer = vertices.get(i); final Optional<Vertex> first = layer.getVertices() .stream() .filter(v -> Objects.equals(v.getId(), vertex)) .findFirst(); return first.map(vertex1 -> layer.getVertices().indexOf(vertex1)).orElse(-1);
for (int j = layers.size() - 1; j >= 1; j--) { final GraphLayer currentLayer = layers.get(j); for (final Vertex vertex : currentLayer.getVertices()) { currentLayer.getVertices().sort(Vertex::compareTo); final GraphLayer currentLayer = layers.get(j); for (final Vertex vertex : layers.get(j).getVertices()) { final double median = calculateMedianOfVerticesConnectedTo(vertex.getId(), layers.get(j + 1), edges); vertex.setMedian(median); currentLayer.getVertices().sort(Vertex::compareTo);
nestedBestRanks[i] = new Object[layer.getVertices().size()]; for (int j = 0; j < layer.getVertices().size(); j++) { nestedBestRanks[i][j] = layer.getVertices().get(j);
@Override public void calculateVerticesPositions(final ReorderedGraph graph, final LayerArrangement arrangement) { final LayeredGraph layered = (LayeredGraph)graph; for (final OrientedEdge edge : graph.getEdges()) { if (edge.isReversed()) { edge.reverse(); } } final Set<Vertex> vertices = layered.getLayers().stream() .flatMap(l -> l.getVertices().stream()).collect(Collectors.toSet()); removeVirtualVertices(graph.getEdges(), vertices); removeVirtualVerticesFromLayers(layered.getLayers(), vertices); calculateVerticesPosition(layered.getLayers(), arrangement); }
final GraphLayer currentLayer = virtualized.get(i); final GraphLayer nextLayer = virtualized.get(i + 1); for (final Vertex vertex : currentLayer.getVertices()) { nextLayer.getVertices().add(virtualVertex); edges.remove(edge); final OrientedEdge v1 = new OrientedEdgeImpl(edge.getFromVertexId(), virtualVertex.getId()); nextLayer.getVertices().add(virtualVertex); edges.remove(edge); final OrientedEdge v1 = new OrientedEdgeImpl(virtualVertex.getId(), edge.getToVertexId());
for (final Vertex v : layer.getVertices()) { final Node n = indexByUuid.get(v.getId());
@Test public void testSimpleReorder() { final LayeredGraph graph = new LayeredGraph(); graph.addEdge("A", "D"); graph.addEdge("B", "C"); final GraphLayerImpl layer01 = new GraphLayerImpl(1); layer01.addNewVertex("A"); layer01.addNewVertex("B"); graph.getLayers().add(layer01); final GraphLayerImpl layer02 = new GraphLayerImpl(2); layer02.addNewVertex("C"); layer02.addNewVertex("D"); graph.getLayers().add(layer02); final MedianVertexLayerPositioning median = new MedianVertexLayerPositioning(); final LayerCrossingCount layersCount = new LayerCrossingCount(); final VerticesTransposer verticesTransposer = new VerticesTransposer(layersCount); final DefaultVertexOrdering ordering = new DefaultVertexOrdering(median, layersCount, verticesTransposer); ordering.orderVertices(graph); Assertions.assertThat(graph.getLayers().get(0).getVertices()) .extracting(Vertex::getId) .containsExactly("A", "B"); Assertions.assertThat(graph.getLayers().get(1).getVertices()) .extracting(Vertex::getId) .containsExactly("D", "C"); }
final List<GraphLayer> orderedLayers = graph.getLayers(); Assertions.assertThat(orderedLayers.get(0).getVertices()) .extracting(Vertex::getId) .containsExactly("A"); Assertions.assertThat(orderedLayers.get(1).getVertices()) .extracting(Vertex::getId) .containsExactly("D", "B", "C"); Assertions.assertThat(orderedLayers.get(2).getVertices()) .extracting(Vertex::getId) .containsExactly("F", "E", "G", "H");