Provide JSON coordinate options

plugins/org.eclipse.elk.core/src/org/eclipse/elk/core/Core.melk

@@ -302,6 +302,19 @@ advanced option omitNodeMicroLayout: boolean {
     targets parents
 }
 
+// --- JSON
+group json {
+
+    option edgeCoords: EdgeCoords {
+        label "Edge Coords"
+        description
+            "Specify the coordinate system for edge route points."
+        default = EdgeCoords.INHERIT
+        targets parents
+    }
+
+}
+
 // --- SPACING
 group spacing {
 

plugins/org.eclipse.elk.core/src/org/eclipse/elk/core/options/EdgeCoords.java

@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2015 Kiel University and others.
+ * 
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.elk.core.options;
+
+/**
+ * Definition of edge coordinate systems. To be accessed using {@link CoreOptions#JSON_EDGE_COORDS}.
+ */
+public enum EdgeCoords {
+
+    /**
+     * Inherit the parent node's coordinate system. The root node has no parent node; here, this setting defaults to
+     * {@link #CONTAINER}.
+     */
+    INHERIT,
+    /** relative to the edge's proper container node. */
+    CONTAINER,
+    /** relative to the edge's JSON parent node. */
+    PARENT,
+    /** relative to the root node, a.k.a. global coordinates. */
+    ROOT;
+
+}

plugins/org.eclipse.elk.graph.json/src/org/eclipse/elk/graph/json/JsonImporter.xtend

@@ -17,6 +17,7 @@ import com.google.common.collect.Multimap
 import java.util.Map
 import org.eclipse.elk.core.data.LayoutMetaDataService
 import org.eclipse.elk.core.options.CoreOptions
+import org.eclipse.elk.core.options.EdgeCoords
 import org.eclipse.elk.core.util.IndividualSpacings
 import org.eclipse.elk.graph.ElkEdge
 import org.eclipse.elk.graph.ElkEdgeSection
@@ -58,6 +59,11 @@ final class JsonImporter {
     val Map<ElkEdge, Object> edgeJsonMap = Maps.newHashMap
     val Map<ElkEdgeSection, Object> edgeSectionJsonMap = Maps.newHashMap
     val Map<ElkLabel, Object> labelJsonMap = Maps.newHashMap
+
+    /* Maps to help in adjusting coordinates */
+    val Map<ElkEdge, ElkNode> edgeOriginalParentMap = Maps.newHashMap
+    val Map<ElkNode, Double> nodeGlobalXMap = Maps.newHashMap
+    val Map<ElkNode, Double> nodeGlobalYMap = Maps.newHashMap
 
     var Object inputModel
 
@@ -91,10 +97,16 @@ final class JsonImporter {
         portIdMap.clear 
         edgeIdMap.clear
         edgeSectionIdMap.clear
+
         nodeJsonMap.clear
         portJsonMap.clear
         edgeJsonMap.clear
-        edgeSectionJsonMap.clear 
+        edgeSectionJsonMap.clear
+        labelJsonMap.clear
+
+        edgeOriginalParentMap.clear
+        nodeGlobalXMap.clear
+        nodeGlobalYMap.clear
     }
 
     private def transformChildNodes(Object jsonNodeA, ElkNode parent) {
@@ -525,22 +537,34 @@ final class JsonImporter {
       * Transfer the layout back to the formerly imported graph, using {@link #transform(Object)}.
       */
     def transferLayout(ElkNode graph) {
-        // transfer layout of all elements (including root)
+        // First pass handles everything except edges, and computes global coordinates for all nodes.
         ElkGraphUtil.propertiesSkippingIteratorFor(graph, true).forEach [ element |
-            element.transferLayoutInt
+            element.transferLayoutInt1
+        ]
+
+        // Second pass handles edges.
+        ElkGraphUtil.propertiesSkippingIteratorFor(graph, true).forEach [ element |
+            element.transferLayoutInt2
         ]
     }
 
-    private def dispatch transferLayoutInt(ElkNode node) {
+    private def dispatch transferLayoutInt1(ElkNode node) {
         val jsonObj = nodeJsonMap.get(node)
         if (jsonObj === null) {
             throw formatError("Node did not exist in input.")
         }
+        // Compute global coordinates, to support coordinate adjustments.
+        val parent = node.getParent
+        val dx = parent.globalX ?: 0
+        val dy = parent.globalY ?: 0
+        nodeGlobalXMap.put(node, node.x + dx)
+        nodeGlobalYMap.put(node, node.y + dy)
+
         // transfer positions and dimension
         node.transferShapeLayout(jsonObj)
     }
 
-    private def dispatch transferLayoutInt(ElkPort port) {
+    private def dispatch transferLayoutInt1(ElkPort port) {
         val jsonObj = portJsonMap.get(port)
         if (jsonObj === null) {
             throw formatError("Port did not exist in input.")
@@ -549,14 +573,46 @@ final class JsonImporter {
         // transfer positions and dimension
         port.transferShapeLayout(jsonObj)
     }
+
+    private def EdgeCoords getEdgeCoordsMode(ElkNode node) {
+        var ancestor = node
+        var ecm = EdgeCoords.INHERIT
+        do {
+            if (ancestor !== null) {
+                ecm = ancestor.getProperty(CoreOptions.JSON_EDGE_COORDS) ?: EdgeCoords.INHERIT
+            } else {
+                ecm = EdgeCoords.CONTAINER
+            }
+            ancestor = ancestor.getParent
+        } while (ecm === EdgeCoords.INHERIT)
+        return ecm
+    }
+
+    private def Double adjustX(ElkEdge edge, EdgeCoords mode, Double x) {
+        switch mode {
+            case EdgeCoords.ROOT: x + edge.getContainingNode.globalX
+            case EdgeCoords.PARENT: x + edge.getContainingNode.globalX - edge.originalParent.globalX
+            default: x
+        }
+    }
+
+    private def Double adjustY(ElkEdge edge, EdgeCoords mode, Double y) {
+        switch mode {
+            case EdgeCoords.ROOT: y + edge.getContainingNode.globalY
+            case EdgeCoords.PARENT: y + edge.getContainingNode.globalY - edge.originalParent.globalY
+            default: y
+        }
+    }
 
-    private def dispatch transferLayoutInt(ElkEdge edge) {
+    private def dispatch transferLayoutInt2(ElkEdge edge) {
         val jsonObj = edgeJsonMap.get(edge).toJsonObject
         if (jsonObj === null) {
             throw formatError("Edge did not exist in input.")
         }
 
         val edgeId = jsonObj.id
+
+        val ecm = edge.originalParent.getEdgeCoordsMode
 
         // what we need to transfer are the edge sections
         if (!edge.sections.nullOrEmpty) {
@@ -576,23 +632,23 @@ final class JsonImporter {
 
                 // Start Point
                 val startPoint = newJsonObject
-                startPoint.addJsonObj("x", elkSection.startX)
-                startPoint.addJsonObj("y", elkSection.startY)
+                startPoint.addJsonObj("x", edge.adjustX(ecm, elkSection.startX))
+                startPoint.addJsonObj("y", edge.adjustY(ecm, elkSection.startY))
                 jsonSection.addJsonObj("startPoint", startPoint)
 
                 // End Point
                 val endPoint = newJsonObject
-                endPoint.addJsonObj("x", elkSection.endX)
-                endPoint.addJsonObj("y", elkSection.endY)
+                endPoint.addJsonObj("x", edge.adjustX(ecm, elkSection.endX))
+                endPoint.addJsonObj("y", edge.adjustY(ecm, elkSection.endY))
                 jsonSection.addJsonObj("endPoint", endPoint)
 
                 // Bend Points
                 if (!elkSection.bendPoints.nullOrEmpty) {
                     val bendPoints = newJsonArray
                     elkSection.bendPoints.forEach [ pnt |
                         val jsonPnt = newJsonObject
-                        jsonPnt.addJsonObj("x", pnt.x)
-                        jsonPnt.addJsonObj("y", pnt.y)
+                        jsonPnt.addJsonObj("x", edge.adjustX(ecm, pnt.x))
+                        jsonPnt.addJsonObj("y", edge.adjustY(ecm, pnt.y))
                         bendPoints.addJsonArr(jsonPnt)
                     ]
                     jsonSection.addJsonObj("bendPoints", bendPoints)
@@ -637,25 +693,29 @@ final class JsonImporter {
                 val jsonJPs = newJsonArray
                 jps.forEach[ jp |
                     val jsonPnt = newJsonObject
-                    jsonPnt.addJsonObj("x", jp.x)
-                    jsonPnt.addJsonObj("y", jp.y)
+                    jsonPnt.addJsonObj("x", edge.adjustX(ecm, jp.x))
+                    jsonPnt.addJsonObj("y", edge.adjustY(ecm, jp.y))
                     jsonJPs.addJsonArr(jsonPnt)
                 ]
                 jsonObj.addJsonObj("junctionPoints", jsonJPs)
             }
         }
 
-        jsonObj.addJsonObj("container", edge.getContainingNode().identifier)
+        jsonObj.addJsonObj("container", edge.getContainingNode.identifier)
     }
 
-    private def dispatch transferLayoutInt(ElkLabel label) {
+    private def dispatch transferLayoutInt1(ElkLabel label) {
         val jsonObj = labelJsonMap.get(label)
 
         // transfer positions and dimension
         label.transferShapeLayout(jsonObj)
     }
 
-    private def dispatch transferLayoutInt(Object obj) {
+    private def dispatch transferLayoutInt1(Object obj) {
+        // don't care about the rest
+    }
+
+    private def dispatch transferLayoutInt2(Object obj) {
         // don't care about the rest
     }
 
@@ -708,6 +768,7 @@ final class JsonImporter {
 
         edgeIdMap.put(id, edge)
         edgeJsonMap.put(edge, obj)
+        edgeOriginalParentMap.put(edge, edge.getContainingNode)
 
         return edge
     }
@@ -720,5 +781,17 @@ final class JsonImporter {
 
         return edgeSection
     }
+
+    private def ElkNode originalParent(ElkEdge edge) {
+        return edgeOriginalParentMap.get(edge)
+    }
+
+    private def Double globalX(ElkNode node) {
+        return nodeGlobalXMap.get(node)
+    }
+
+    private def Double globalY(ElkNode node) {
+        return nodeGlobalYMap.get(node)
+    }
 
 }