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

Example 6 with LEdge

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

the class InvertedPortProcessor method process.

@Override
public void process(final LGraph layeredGraph, final IElkProgressMonitor monitor) {
    monitor.begin("Inverted port preprocessing", 1);
    // Retrieve the layers in the graph
    List<Layer> layers = layeredGraph.getLayers();
    // Iterate through the layers and for each layer create a list of dummy nodes
    // that were created, but not yet assigned to the layer (to avoid concurrent
    // modification exceptions)
    ListIterator<Layer> layerIterator = layers.listIterator();
    Layer currentLayer = null;
    List<LNode> unassignedNodes = Lists.newArrayList();
    while (layerIterator.hasNext()) {
        // Update previous and current layers
        Layer previousLayer = currentLayer;
        currentLayer = layerIterator.next();
        // If the previous layer had unassigned nodes, assign them now and clear the list
        for (LNode node : unassignedNodes) {
            node.setLayer(previousLayer);
        }
        unassignedNodes.clear();
        // Iterate through the layer's nodes
        for (LNode node : currentLayer) {
            // Skip dummy nodes
            if (node.getType() != NodeType.NORMAL) {
                continue;
            }
            // port side problem won't appear)
            if (!node.getProperty(LayeredOptions.PORT_CONSTRAINTS).isSideFixed()) {
                continue;
            }
            // Look for input ports on the right side
            for (LPort port : node.getPorts(PortType.INPUT, PortSide.EAST)) {
                // For every edge going into this port, insert dummy nodes (do this using
                // a copy of the current list of edges, since the edges are modified when
                // dummy nodes are created)
                List<LEdge> edges = port.getIncomingEdges();
                LEdge[] edgeArray = LGraphUtil.toEdgeArray(edges);
                for (LEdge edge : edgeArray) {
                    createEastPortSideDummies(layeredGraph, port, edge, unassignedNodes);
                }
            }
            // Look for ports on the left side connected to edges going to higher layers
            for (LPort port : node.getPorts(PortType.OUTPUT, PortSide.WEST)) {
                // For every edge going out of this port, insert dummy nodes (do this using
                // a copy of the current list of edges, since the edges are modified when
                // dummy nodes are created)
                List<LEdge> edges = port.getOutgoingEdges();
                LEdge[] edgeArray = LGraphUtil.toEdgeArray(edges);
                for (LEdge edge : edgeArray) {
                    createWestPortSideDummies(layeredGraph, port, edge, unassignedNodes);
                }
            }
        }
    }
    // There may be unassigned nodes left
    for (LNode node : unassignedNodes) {
        node.setLayer(currentLayer);
    }
    monitor.done();
}

Example 7 with LEdge

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

the class LabelDummySwitcher method swapNodes.

/**
 * Swaps the two given label dummy with the given long edge dummy. The dummies are assumed to be part of the same
 * long edge. The label dummy's new layer's width in the {@link #layerWidths} array is enlarged if the label dummy
 * is wider than the layer currently is.
 */
private void swapNodes(final LNode labelDummy, final LNode longEdgeDummy) {
    // Find the layers and the positions inside the layers of the dummy nodes. We need the positions later since
    // we run after crossing minimization and have to keep the order of nodes the same. An alternative for this
    // method would be not to change the layers and connections of the two nodes but to switch all of their
    // properties instead, but we reckon that might actually be more work
    Layer layer1 = labelDummy.getLayer();
    Layer layer2 = longEdgeDummy.getLayer();
    int dummy1LayerPosition = layer1.getNodes().indexOf(labelDummy);
    int dummy2LayerPosition = layer2.getNodes().indexOf(longEdgeDummy);
    // Detect incoming and outgoing ports of the nodes (this of course assumes that there's just one of each kind,
    // which should be true for long edge and label dummy nodes)
    LPort inputPort1 = labelDummy.getPorts(PortType.INPUT).iterator().next();
    LPort outputPort1 = labelDummy.getPorts(PortType.OUTPUT).iterator().next();
    LPort inputPort2 = longEdgeDummy.getPorts(PortType.INPUT).iterator().next();
    LPort outputPort2 = longEdgeDummy.getPorts(PortType.OUTPUT).iterator().next();
    // Store incoming and outgoing edges
    LEdge[] incomingEdges1 = LGraphUtil.toEdgeArray(inputPort1.getIncomingEdges());
    LEdge[] outgoingEdges1 = LGraphUtil.toEdgeArray(outputPort1.getOutgoingEdges());
    LEdge[] incomingEdges2 = LGraphUtil.toEdgeArray(inputPort2.getIncomingEdges());
    LEdge[] outgoingEdges2 = LGraphUtil.toEdgeArray(outputPort2.getOutgoingEdges());
    // Put first dummy into second dummy's layer and reroute second dummy's edges to first dummy
    labelDummy.setLayer(dummy2LayerPosition, layer2);
    for (LEdge edge : incomingEdges2) {
        edge.setTarget(inputPort1);
    }
    for (LEdge edge : outgoingEdges2) {
        edge.setSource(outputPort1);
    }
    // Put second dummy into first dummy's layer and reroute first dummy's edges to second dummy
    longEdgeDummy.setLayer(dummy1LayerPosition, layer1);
    for (LEdge edge : incomingEdges1) {
        edge.setTarget(inputPort2);
    }
    for (LEdge edge : outgoingEdges1) {
        edge.setSource(outputPort2);
    }
}

Example 8 with LEdge

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

the class LabelDummySwitcher method isPartOfReversedEdge.

/**
 * Checks if the given label dummy node is part of a reversed edge.
 */
private boolean isPartOfReversedEdge(final LabelDummyInfo labelDummyInfo) {
    assert labelDummyInfo.labelDummy.getType() == NodeType.LABEL;
    assert labelDummyInfo.labelDummy.getIncomingEdges().iterator().hasNext();
    assert labelDummyInfo.labelDummy.getOutgoingEdges().iterator().hasNext();
    // Find incoming and outgoing edge
    LEdge incoming = labelDummyInfo.labelDummy.getIncomingEdges().iterator().next();
    LEdge outgoing = labelDummyInfo.labelDummy.getOutgoingEdges().iterator().next();
    return incoming.getProperty(InternalProperties.REVERSED) || outgoing.getProperty(InternalProperties.REVERSED);
}

Example 9 with LEdge

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

the class LabelManagementProcessor method manageNonCenterLabels.

// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Everything Except Center Edge Labels
/**
 * Calls label management on all labels that are not edge center labels.
 */
private void manageNonCenterLabels(final LGraph lGraph, final ILabelManager labelManager, final double labelLabelSpacing) {
    boolean verticalLayout = lGraph.getProperty(LayeredOptions.DIRECTION).isVertical();
    // Iterate over the layers
    for (Layer layer : lGraph) {
        // Apply label management to node and port labels
        for (LNode node : layer) {
            if (node.getType() == NodeType.NORMAL) {
                // Handle node labels
                doManageLabels(labelManager, node.getLabels(), MIN_WIDTH_NODE_LABELS, labelLabelSpacing, verticalLayout);
                // Handle ports
                List<LPort> ports = node.getPorts();
                for (LPort port : ports) {
                    doManageLabels(labelManager, port.getLabels(), MIN_WIDTH_PORT_LABELS, labelLabelSpacing, verticalLayout);
                }
                // Handle attached comments
                if (node.hasProperty(InternalProperties.TOP_COMMENTS)) {
                    doManageAttachedCommentLabels(labelManager, node.getProperty(InternalProperties.TOP_COMMENTS), MIN_WIDTH_NODE_LABELS, verticalLayout);
                }
                if (node.hasProperty(InternalProperties.BOTTOM_COMMENTS)) {
                    doManageAttachedCommentLabels(labelManager, node.getProperty(InternalProperties.BOTTOM_COMMENTS), MIN_WIDTH_NODE_LABELS, verticalLayout);
                }
            }
            // point, only head and tail labels remain)
            for (LEdge edge : node.getOutgoingEdges()) {
                doManageLabels(labelManager, edge.getLabels(), MIN_WIDTH_EDGE_LABELS, 0, verticalLayout);
            }
        }
    }
}

Example 10 with LEdge

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

the class LabelManagementProcessor method manageCenterLabels.

// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Center Edge Labels
/**
 * Calls label management on all edge center labels.
 */
private void manageCenterLabels(final LGraph lGraph, final ILabelManager labelManager, final double edgeLabelSpacing, final double labelLabelSpacing) {
    boolean verticalLayout = lGraph.getProperty(LayeredOptions.DIRECTION).isVertical();
    // Iterate over the layers and find label dummy nodes
    for (Layer layer : lGraph) {
        // The maximum width is used as the target width for center edge labels
        double maxWidth = Math.max(MIN_WIDTH_EDGE_LABELS, LGraphUtil.findMaxNonDummyNodeWidth(layer, false));
        for (LNode node : layer) {
            if (node.getType() == NodeType.LABEL) {
                LEdge edge = node.getConnectedEdges().iterator().next();
                double edgeThickness = edge.getProperty(LayeredOptions.EDGE_THICKNESS).doubleValue();
                // The list of labels should never be empty (otherwise the label dummy wouldn't have been created
                // in the first place)
                Iterable<LLabel> labels = node.getProperty(InternalProperties.REPRESENTED_LABELS);
                KVector spaceRequiredForLabels = doManageLabels(labelManager, labels, maxWidth, labelLabelSpacing, verticalLayout);
                // Apply the space required for labels to the dummy node (we don't bother with the ports here since
                // they will be meddled with later by the LabelSideSelector anyway)
                node.getSize().x = spaceRequiredForLabels.x;
                node.getSize().y = spaceRequiredForLabels.y + edgeThickness + edgeLabelSpacing;
            }
        }
    }
}