Examples with LGraph org.eclipse.elk.alg.layered.graph.LGraph used on opensource projects

Example 46 with LGraph

use of org.eclipse.elk.alg.layered.graph.LGraph in project elk by eclipse.

the class GreedyPortDistributorTest method givenMoreHierarchicalNodes_DoesNotSwitchPorts.

/**
 * <pre>
 * ____
 * |*-+  *
 * |  |\/
 * |*-+/\
 * |  |  *
 * |*-+--*
 * |--|
 * </pre>
 */
@Test
public void givenMoreHierarchicalNodes_DoesNotSwitchPorts() {
    LNode leftOuterNode = addNodeToLayer(makeLayer(getGraph()));
    LNode[] rightNodes = addNodesToLayer(3, makeLayer(getGraph()));
    LPort[] leftOuterPorts = addPortsOnSide(3, leftOuterNode, PortSide.EAST);
    eastWestEdgeFromTo(leftOuterPorts[0], rightNodes[1]);
    eastWestEdgeFromTo(leftOuterPorts[1], rightNodes[0]);
    eastWestEdgeFromTo(leftOuterPorts[2], rightNodes[2]);
    LGraph leftInnerGraph = nestedGraph(leftOuterNode);
    LNode[] leftInnerNodes = addNodesToLayer(3, makeLayer(leftInnerGraph));
    LNode[] leftInnerDummyNodes = addExternalPortDummiesToLayer(makeLayer(leftInnerGraph), leftOuterPorts);
    eastWestEdgeFromTo(leftInnerNodes[0], leftInnerDummyNodes[0]);
    eastWestEdgeFromTo(leftInnerNodes[1], leftInnerDummyNodes[1]);
    eastWestEdgeFromTo(leftInnerNodes[2], leftInnerDummyNodes[2]);
    // Order stays the same.
    List<LPort> expectedPortOrderLeftNode = portsOrderedAs(leftOuterNode, 0, 1, 2);
    setUpDistributor();
    portDist.distributePortsWhileSweeping(graph.toNodeArray(), 0, false);
    assertThat(leftOuterNode.getPorts(), is(expectedPortOrderLeftNode));
}

Example 47 with LGraph

use of org.eclipse.elk.alg.layered.graph.LGraph in project elk by eclipse.

the class BasicNodePlacementTest method testProperCoordinates.

// ////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Tests
@TestAfterProcessor(BKNodePlacer.class)
@TestAfterProcessor(LinearSegmentsNodePlacer.class)
@TestAfterProcessor(NetworkSimplexPlacer.class)
@TestAfterProcessor(SimpleNodePlacer.class)
public void testProperCoordinates(final Object graph) {
    LGraph lGraph = (LGraph) graph;
    for (Layer layer : lGraph) {
        Iterator<LNode> nodeIter = layer.getNodes().iterator();
        LNode node = nodeIter.next();
        double lastBottomY = node.getPosition().y + node.getSize().y;
        while (nodeIter.hasNext()) {
            node = nodeIter.next();
            assertTrue(lastBottomY < node.getPosition().y);
            lastBottomY = node.getPosition().y + node.getSize().y;
        }
    }
}

Example 48 with LGraph

use of org.eclipse.elk.alg.layered.graph.LGraph in project elk by eclipse.

the class LayerSweepCrossingMinimizerTest method nonRecursive_givenGraphWithCrossingWithFixedPortOrderToHierarchicalGraph_ShouldRemoveCrossing.

/**
 * <pre>
 * ___  ____
 * | |\/+-*|
 * |_|/\|  |
 *      |--|
 * </pre>
 */
@Test
public void nonRecursive_givenGraphWithCrossingWithFixedPortOrderToHierarchicalGraph_ShouldRemoveCrossing() {
    LNode leftNode = addNodeToLayer(makeLayer(getGraph()));
    setFixedOrderConstraint(leftNode);
    LNode rightOuterNode = addNodeToLayer(makeLayer(getGraph()));
    eastWestEdgeFromTo(leftNode, rightOuterNode);
    LPort rightOuterPort = addPortOnSide(rightOuterNode, PortSide.WEST);
    LPort leftLowerPort = addPortOnSide(leftNode, PortSide.EAST);
    addEdgeBetweenPorts(leftLowerPort, rightOuterPort);
    LGraph rightInnerGraph = nestedGraph(rightOuterNode);
    LNode rightInnerDummyNode = addExternalPortDummyNodeToLayer(makeLayer(rightInnerGraph), rightOuterPort);
    LNode rightInnerNode = addNodeToLayer(makeLayer(rightInnerGraph));
    eastWestEdgeFromTo(rightInnerDummyNode, rightInnerNode);
    List<LPort> expectedPortOrderRight = Lists.newArrayList(rightOuterNode.getPorts().get(1), rightOuterNode.getPorts().get(0));
    setOnAllGraphs(LayeredOptions.CROSSING_MINIMIZATION_HIERARCHICAL_SWEEPINESS, 1.0, graph);
    setUpAndMinimizeCrossings();
    assertThat(getGraph().getLayers().get(1).getNodes().get(0).getPorts(), is(expectedPortOrderRight));
}

Example 49 with LGraph

use of org.eclipse.elk.alg.layered.graph.LGraph in project elk by eclipse.

the class LayerSweepCrossingMinimizerTest method givenSimpleHierarchicalCrossSweepingFromRightToLeft_ShouldResultInNoCrossing.

/**
 * <pre>
 * ____  ____
 * |*-+  +-*|
 * |  |\/|  |
 * |*-+/\+-*|
 * |--|  |--|
 * </pre>
 */
@Test
public void givenSimpleHierarchicalCrossSweepingFromRightToLeft_ShouldResultInNoCrossing() {
    LNode leftOuterNode = addNodeToLayer(makeLayer(getGraph()));
    LNode rightOuterNode = addNodeToLayer(makeLayer(getGraph()));
    LPort[] leftOuterPorts = addPortsOnSide(2, leftOuterNode, PortSide.EAST);
    LPort[] rightOuterPorts = addPortsOnSide(2, rightOuterNode, PortSide.WEST);
    addEdgeBetweenPorts(leftOuterPorts[0], rightOuterPorts[0]);
    addEdgeBetweenPorts(leftOuterPorts[1], rightOuterPorts[1]);
    LGraph leftInnerGraph = makeNestedTwoNodeGraphWithEasternPorts(leftOuterNode, leftOuterPorts);
    makeNestedTwoNodeGraphWithWesternPorts(rightOuterNode, rightOuterPorts);
    List<LNode> expectedNodeOrderLeft = switchOrderOfNodesInLayer(0, 1, leftInnerGraph.getLayers().get(0));
    List<LPort> expectedOrderOfPortsLeft = Lists.newArrayList(leftOuterPorts[1], leftOuterPorts[0]);
    getRandom().setNextBoolean(false);
    setUpAndMinimizeCrossings();
    assertThat(leftOuterNode.getPorts(), is(expectedOrderOfPortsLeft));
    assertThat(leftInnerGraph.getLayers().get(0).getNodes(), is(expectedNodeOrderLeft));
}

Example 50 with LGraph

use of org.eclipse.elk.alg.layered.graph.LGraph in project elk by eclipse.

the class LayerSweepCrossingMinimizerTest method givenCrossWithNoExternalPortDummiesOnOneNestedGraph_ShouldRemoveCrossing.

/**
 * <pre>
 * ____  ____
 * |*-+  | *|
 * |  |\/|  |
 * |*-+/\| *|
 * |--|  |--|
 * </pre>
 */
@Test
public void givenCrossWithNoExternalPortDummiesOnOneNestedGraph_ShouldRemoveCrossing() {
    LNode leftOuterNode = addNodeToLayer(makeLayer());
    LNode rightOuterNode = addNodeToLayer(makeLayer());
    LPort[] leftOuterPorts = addPortsOnSide(2, leftOuterNode, PortSide.EAST);
    LPort[] rightOuterPorts = addPortsOnSide(2, rightOuterNode, PortSide.WEST);
    addEdgeBetweenPorts(leftOuterPorts[0], rightOuterPorts[0]);
    addEdgeBetweenPorts(leftOuterPorts[1], rightOuterPorts[1]);
    makeNestedTwoNodeGraphWithEasternPorts(leftOuterNode, leftOuterPorts);
    LGraph rightInnerGraph = nestedGraph(rightOuterNode);
    addNodesToLayer(2, makeLayer(rightInnerGraph));
    List<LPort> expectedPortOrderRight = Lists.newArrayList(rightOuterPorts[1], rightOuterPorts[0]);
    setUpAndMinimizeCrossings();
    assertThat(expectedPortOrderRight, is(rightOuterNode.getPorts()));
}