Merge pull request #17 from hbmartin/edge-layout

Calculate SVG curves to layout edges

Author: hbmartin

.gitignore

@@ -135,6 +135,9 @@ Temporary Items
 
 # Generated
 test/**/*.xml
+/*.gv
+/*.dot
+/*.xml
 
 # PyCharm
 .idea/workspace.xml

.idea/dictionaries/haroldmartin.xml

@@ -11,16 +11,21 @@ Convert graphviz (dot) files into draw.io (mxGraph) format
 
 graphviz2drawio requires [Python 3](https://www.python.org/downloads/) and [Graphviz](https://www.graphviz.org/download/)
 
-On Mac OS these can be installed with [Homebrew](https://brew.sh/):
+* On Mac OS these can be installed with [Homebrew](https://brew.sh/):
 
 ```
 brew update; brew install python3 graphviz
 ```
+* On Ubuntu / Debian based Linux, install graphviz using:
 
-### Installation
+```
+sudo apt install graphviz graphviz-dev
+```
+
+### Installation / Upgrade
 
 ```
-pip3 install graphviz2drawio
+pip3 install graphviz2drawio --upgrade
 ```
 ## Usage
 Run the conversion app on your graphviz file
@@ -37,10 +42,10 @@ from graphviz2drawio import graphviz2drawio
 xml = graphviz2drawio.convert(graph_to_convert)
 print(xml)
 ```
-graph_to_convert can be any of a file path, file handle, string of dot language, or PyGraphviz.AGraph object
+where `graph_to_convert` can be any of a file path, file handle, string of dot language, or PyGraphviz.AGraph object
 
 ## Limitations
-Current alpha release may not correctly convert all dot commands. PLEASE [open an issue](https://github.com/hbmartin/graphviz2drawio/issues) with your dot file to report conversion problems or visual errors.
+Please [open an issue](https://github.com/hbmartin/graphviz2drawio/issues) with your dot file to report crashes or incorrectect conversions.
 
 ## Built With
 
@@ -59,6 +64,7 @@ This project makes strict use of Black for code formatting. See the [Black page]
 ## Authors
 
 * [Harold Martin](https://www.linkedin.com/in/harold-martin-98526971/) - harold.martin at gmail
+* Jonah Caplan
 
 ## License
 

README.md

@@ -3,6 +3,9 @@ def __init__(self, x, y):
         self.x = x
         self.y = y
 
+    def complex_translate(self, cnum):
+        return complex(cnum.real + self.x, cnum.imag + self.y)
+
     def translate(self, x, y):
         return float(x) + self.x, float(y) + self.y
 

graphviz2drawio/models/CoordsTranslate.py

@@ -7,10 +7,34 @@ def __init__(self, x, y, width, height):
         self.bottom = y + height
         self.right = x + width
 
-    def to_dict_int(self):
+    def x_ratio(self, search):
+        if search < self.x:
+            return 0
+        elif search > self.x + self.width:
+            return 1
+        else:
+            ratio = (search - self.x) / self.width
+            return self._approx(ratio, 0.5, 0.1)
+
+    def y_ratio(self, search):
+        if search < self.y:
+            return 0
+        elif search > self.y + self.height:
+            return 1
+        else:
+            ratio = (search - self.y) / self.height
+            return self._approx(ratio, 0.5, 0.1)
+
+    @staticmethod
+    def _approx(value, center, delta):
+        if abs(value - center) < delta:
+            return center
+        return value
+
+    def to_dict_str(self):
         return {
-            "x": str(int(self.x)),
-            "y": str(int(self.y)),
-            "width": str(int(self.width)),
-            "height": str(int(self.height)),
+            "x": str(self.x),
+            "y": str(self.y),
+            "width": str(self.width),
+            "height": str(self.height),
         }

graphviz2drawio/models/Rect.py

@@ -1,21 +1,22 @@
 from xml.etree import ElementTree
 from . import SVG
 from .CoordsTranslate import CoordsTranslate
-from graphviz2drawio.mx.Edge import Edge
+from graphviz2drawio.mx.EdgeFactory import EdgeFactory
 from graphviz2drawio.mx.NodeFactory import NodeFactory
 from collections import OrderedDict
 
 
 class SvgParser:
     def __init__(self, svg_data):
-        super(SvgParser, self).__init__()
         self.svg_data = svg_data
 
     def get_nodes_and_edges(self):
         root = ElementTree.fromstring(self.svg_data)[0]
 
         coords = CoordsTranslate.from_svg_transform(root.attrib["transform"])
         node_factory = NodeFactory(coords)
+        edge_factory = EdgeFactory(coords)
+
         nodes = OrderedDict()
         edges = []
 
@@ -25,6 +26,6 @@ def get_nodes_and_edges(self):
                 if g.attrib["class"] == "node":
                     nodes[title] = node_factory.from_svg(g)
                 elif g.attrib["class"] == "edge":
-                    edges.append(Edge.from_svg(g))
+                    edges.append(edge_factory.from_svg(g))
 
         return nodes, edges

graphviz2drawio/models/SvgParser.py

@@ -0,0 +1,56 @@
+from . import LinearRegression
+
+linear_min_r2 = 0.9
+
+
+class Curve:
+    def __init__(self, start, end, cb):
+        """Takes complex numbers for start, end, and list of 4 Bezier control points"""
+        self.start = start
+        self.end = end
+        assert cb is None or len(cb) == 4
+        self.cb = cb
+
+    def __str__(self):
+        control = "[" + (str(self.cb) if self.cb is not None else "None") + "]"
+        return str(self.start) + ", " + control + ", " + str(self.end)
+
+    @staticmethod
+    def is_linear(points, threshold=linear_min_r2):
+        """
+        Returns a boolean indicating whether a list of complex points is linear.
+
+        Takes a list of complex points and optional minimum R**2 threshold for linear regression.
+        """
+        r2 = LinearRegression.coefficients(points)[2]
+        return r2 > threshold
+
+    def cubic_bezier_coordinates(self, t):
+        """
+        Returns a complex number representing the point along the cubic bezier curve.
+
+        Takes parametric parameter t where 0 <= t <= 1
+        """
+        x = Curve._cubic_bezier(self._cb("real"), t)
+        y = Curve._cubic_bezier(self._cb("imag"), t)
+        return complex(x, y)
+
+    def _cb(self, prop):
+        return [getattr(x, prop) for x in self.cb]
+
+    @staticmethod
+    def _cubic_bezier(p, t):
+        """
+        Returns a float representing the point along the cubic bezier curve in the given dimension.
+
+        Takes ordered list of 4 control points [P0, P1, P2, P3] and parametric parameter t where 0 <= t <= 1
+
+        implements explicit form of https://en.wikipedia.org/wiki/B%C3%A9zier_curve#Cubic_B%C3%A9zier_curves
+        """
+        assert 0 <= t <= 1
+        return (
+            (((1.0 - t) ** 3) * p[0])
+            + (3.0 * t * ((1.0 - t) ** 2) * p[1])
+            + (3.0 * (t ** 2) * (1.0 - t) * p[2])
+            + ((t ** 3) * p[3])
+        )

graphviz2drawio/mx/Curve.py

@@ -0,0 +1,21 @@
+from svg.path import CubicBezier
+from svg.path import parse_path
+from .Curve import Curve
+
+
+class CurveFactory:
+    def __init__(self, coords):
+        super(CurveFactory, self).__init__()
+        self.coords = coords
+
+    def from_svg(self, svg_path):
+        path = parse_path(svg_path)
+        start = self.coords.complex_translate(path[0].start)
+        end = self.coords.complex_translate(path[1].end)
+        cb = None
+        if isinstance(path[1], CubicBezier):
+            # TODO: needs to account for multiple bezier in path
+            points = [path[1].start, path[1].control1, path[1].control2, path[1].end]
+            if not Curve.is_linear(points):
+                cb = [self.coords.complex_translate(p) for p in points]
+        return Curve(start=start, end=end, cb=cb)

graphviz2drawio/mx/CurveFactory.py

@@ -1,18 +1,12 @@
-from graphviz2drawio.models import SVG
 from .GraphObj import GraphObj
 
 
 class Edge(GraphObj):
-    def __init__(self, sid, gid, fr, to):
+    def __init__(self, sid, gid, fr, to, curve):
         super(Edge, self).__init__(sid, gid)
         self.fr = fr
         self.to = to
+        self.curve = curve
         self.style = None
         self.dir = None
         self.arrowtail = None
-
-    @staticmethod
-    def from_svg(g):
-        gid = SVG.get_title(g).replace("--", "->")
-        fr, to = gid.split("->")
-        return Edge(sid=g.attrib["id"], gid=gid, fr=fr, to=to)

graphviz2drawio/mx/Edge.py

@@ -0,0 +1,19 @@
+from graphviz2drawio.models import SVG
+from .CurveFactory import CurveFactory
+from .Edge import Edge
+
+
+class EdgeFactory:
+    def __init__(self, coords):
+        super(EdgeFactory, self).__init__()
+        self.curve_factory = CurveFactory(coords)
+
+    def from_svg(self, g):
+        gid = SVG.get_title(g).replace("--", "->")
+        fr, to = gid.split("->")
+        curve = None
+        if SVG.has(g, "path"):
+            path = SVG.get_first(g, "path")
+            if "d" in path.attrib:
+                curve = self.curve_factory.from_svg(path.attrib["d"])
+        return Edge(sid=g.attrib["id"], gid=gid, fr=fr, to=to, curve=curve)