Merge pull request #284 from nschloe/patch-edges

Patch edges

Author: nschloe

matplotlib2tikz/line2d.py

@@ -24,8 +24,7 @@ def draw_line2d(data, obj):
         return data, []
 
     # get the linewidth (in pt)
-    line_width = _mpl_linewidth2pgfp_linewidth(data, obj.get_linewidth())
-
+    line_width = mypath.mpl_linewidth2pgfp_linewidth(data, obj.get_linewidth())
     if line_width:
         addplot_options.append(line_width)
 
@@ -38,8 +37,8 @@ def draw_line2d(data, obj):
     if alpha is not None:
         addplot_options.append("opacity={}".format(alpha))
 
-    show_line, linestyle = _mpl_linestyle2pgfp_linestyle(obj.get_linestyle())
-    if show_line and linestyle:
+    linestyle = mypath.mpl_linestyle2pgfplots_linestyle(obj.get_linestyle())
+    if linestyle is not None and linestyle != "solid":
         addplot_options.append(linestyle)
 
     marker_face_color = obj.get_markerfacecolor()
@@ -59,7 +58,7 @@ def draw_line2d(data, obj):
             line_xcolor,
         )
 
-    if marker and not show_line:
+    if marker and linestyle is None:
         addplot_options.append("only marks")
 
     # Check if a line is in a legend and forget it if not.
@@ -92,51 +91,11 @@ def draw_linecollection(data, obj):
     paths = obj.get_paths()
 
     for i, path in enumerate(paths):
-        if i < len(edgecolors):
-            color = edgecolors[i]
-        else:
-            color = edgecolors[0]
-
-        if i < len(linestyles):
-            style = linestyles[i]
-        else:
-            style = linestyles[0]
-
-        if i < len(linewidths):
-            width = linewidths[i]
-        else:
-            width = linewidths[0]
-
-        data, options = mypath.get_draw_options(data, color, None)
-
-        width = _mpl_linewidth2pgfp_linewidth(data, width)
-        if width:
-            options.append(width)
-
-        # linestyle is a string or dash tuple. Legal string values are
-        # solid|dashed|dashdot|dotted.  The dash tuple is (offset, onoffseq)
-        # where onoffseq is an even length tuple of on and off ink in points.
-        #
-        # solid: [(None, None), (None, None), ..., (None, None)]
-        # dashed: (0, (6.0, 6.0))
-        # dotted: (0, (1.0, 3.0))
-        # dashdot: (0, (3.0, 5.0, 1.0, 5.0))
-        if style[0] is not None:
-            assert isinstance(style, tuple)
-            if len(style[1]) == 2:
-                linestyle = "dash pattern=on {:d}pt off {:d}pt".format(
-                    int(style[1][0]), int(style[1][1])
-                )
-            else:
-                assert len(style[1]) == 4
-                linestyle = "dash pattern=on {:d}pt off {:d}pt on {:d}pt off {:d}pt".format(
-                    int(style[1][0]),
-                    int(style[1][1]),
-                    int(style[1][2]),
-                    int(style[1][3]),
-                )
+        color = edgecolors[i] if i < len(edgecolors) else edgecolors[0]
+        style = linestyles[i] if i < len(linestyles) else linestyles[0]
+        width = linewidths[i] if i < len(linewidths) else linewidths[0]
 
-            options.append(linestyle)
+        data, options = mypath.get_draw_options(data, obj, color, None, style, width)
 
         # TODO what about masks?
         data, cont, _, _ = mypath.draw_path(
@@ -147,51 +106,6 @@ def draw_linecollection(data, obj):
     return data, content
 
 
-TIKZ_LINEWIDTHS = {
-    0.1: "ultra thin",
-    0.2: "very thin",
-    0.4: "thin",
-    0.6: "semithick",
-    0.8: "thick",
-    1.2: "very thick",
-    1.6: "ultra thick",
-}
-
-
-def _mpl_linewidth2pgfp_linewidth(data, line_width):
-    if data["strict"]:
-        # Takes the matplotlib linewidths, and just translate them
-        # into PGFPlots.
-        try:
-            return TIKZ_LINEWIDTHS[line_width]
-        except KeyError:
-            # explicit line width
-            return "line width={}pt".format(line_width)
-    else:
-        # The following is an alternative approach to line widths.
-        # The default line width in matplotlib is 1.0pt, in PGFPlots 0.4pt
-        # ('thin').
-        # Match the two defaults, and scale for the rest.
-        scaled_line_width = line_width / 1.0  # scale by default line width
-        literals = {
-            0.25: "ultra thin",
-            0.5: "very thin",
-            1.0: None,  # default, 'thin'
-            1.5: "semithick",
-            2: "thick",
-            3: "very thick",
-            4: "ultra thick",
-        }
-
-        try:
-            out = literals[scaled_line_width]
-        except KeyError:
-            # explicit line width
-            out = "line width={}pt".format(0.4 * line_width)
-
-        return out
-
-
 # for matplotlib markers, see: http://matplotlib.org/api/markers_api.html
 _MP_MARKER2PGF_MARKER = {
     ".": "*",  # point
@@ -263,26 +177,6 @@ def _mpl_marker2pgfp_marker(data, mpl_marker, marker_face_color):
     return data, None, None
 
 
-_MPLLINESTYLE_2_PGFPLOTSLINESTYLE = {
-    "": None,
-    "None": None,
-    "none": None,  # happens when using plt.boxplot()
-    "-": None,
-    ":": "dotted",
-    "--": "dashed",
-    "-.": "dash pattern=on 1pt off 3pt on 3pt off 3pt",
-}
-
-
-def _mpl_linestyle2pgfp_linestyle(line_style):
-    """Translates a line style of matplotlib to the corresponding style
-    in PGFPlots.
-    """
-    show_line = line_style != "None"
-    style = _MPLLINESTYLE_2_PGFPLOTSLINESTYLE[line_style]
-    return show_line, style
-
-
 # def _transform_to_data_coordinates(obj, xdata, ydata):
 #     '''The coordinates might not be in data coordinates, but could be partly
 #     in axes coordinates.  For example, the matplotlib command
@@ -425,5 +319,4 @@ def _table(obj, content, data):
         content.extend(plot_table)
 
     content.append("};\n")
-
     return

matplotlib2tikz/patch.py

@@ -10,7 +10,12 @@ def draw_patch(data, obj):
     """
     # Gather the draw options.
     data, draw_options = mypath.get_draw_options(
-        data, obj.get_edgecolor(), obj.get_facecolor()
+        data,
+        obj,
+        obj.get_edgecolor(),
+        obj.get_facecolor(),
+        obj.get_linestyle(),
+        obj.get_linewidth(),
     )
 
     if isinstance(obj, mpl.patches.Rectangle):
@@ -33,16 +38,26 @@ def draw_patchcollection(data, obj):
     content = []
     # Gather the draw options.
     try:
-        edge_color = obj.get_edgecolor()[0]
+        ec = obj.get_edgecolor()[0]
     except IndexError:
-        edge_color = None
+        ec = None
 
     try:
-        face_color = obj.get_facecolor()[0]
+        fc = obj.get_facecolor()[0]
     except IndexError:
-        face_color = None
+        fc = None
 
-    data, draw_options = mypath.get_draw_options(data, edge_color, face_color)
+    try:
+        ls = obj.get_linestyle()[0]
+    except IndexError:
+        ls = None
+
+    try:
+        w = obj.get_linewidth()[0]
+    except IndexError:
+        w = None
+
+    data, draw_options = mypath.get_draw_options(data, obj, ec, fc, ls, w)
 
     paths = obj.get_paths()
     for path in paths:

matplotlib2tikz/path.py

@@ -137,26 +137,30 @@ def draw_pathcollection(data, obj):
         table_options.extend(["x=x", "y=y", "meta=colordata"])
         ec = None
         fc = None
+        ls = None
     else:
         # gather the draw options
-        ec = obj.get_edgecolors()
-        fc = obj.get_facecolors()
         try:
-            ec = ec[0]
+            ec = obj.get_edgecolors()[0]
         except (TypeError, IndexError):
             ec = None
+
         try:
-            fc = fc[0]
+            fc = obj.get_facecolors()[0]
         except (TypeError, IndexError):
             fc = None
 
+        try:
+            ls = obj.get_linestyle()[0]
+        except (TypeError, IndexError):
+            ls = None
+
     is_contour = len(dd) == 1
     if is_contour:
         draw_options = ["draw=none"]
 
-    # TODO Use linewidths
-    # linewidths = obj.get_linewidths()
-    data, extra_draw_options = get_draw_options(data, ec, fc)
+    # `only mark` plots don't need linewidth
+    data, extra_draw_options = get_draw_options(data, obj, ec, fc, ls, None)
     draw_options.extend(extra_draw_options)
 
     if obj.get_cmap():
@@ -205,7 +209,7 @@ def draw_pathcollection(data, obj):
     return data, content
 
 
-def get_draw_options(data, ec, fc):
+def get_draw_options(data, obj, ec, fc, style, width):
     """Get the draw options for a given (patch) object.
     """
     draw_options = []
@@ -236,7 +240,88 @@ def get_draw_options(data, ec, fc):
             draw_options.append(("draw opacity=" + ff).format(ec_rgba[3]))
         if fc is not None and fc_rgba[3] != 1.0:
             draw_options.append(("fill opacity=" + ff).format(fc_rgba[3]))
-    # TODO Use those properties
-    # linewidths = obj.get_linewidths()
+
+    if width is not None:
+        w = mpl_linewidth2pgfp_linewidth(data, width)
+        if w:
+            draw_options.append(w)
+
+    if style is not None:
+        ls = mpl_linestyle2pgfplots_linestyle(style)
+        if ls is not None and ls != "solid":
+            draw_options.append(ls)
 
     return data, draw_options
+
+
+def mpl_linewidth2pgfp_linewidth(data, line_width):
+    if data["strict"]:
+        # Takes the matplotlib linewidths, and just translate them into PGFPlots.
+        try:
+            return {
+                0.1: "ultra thin",
+                0.2: "very thin",
+                0.4: "thin",
+                0.6: "semithick",
+                0.8: "thick",
+                1.2: "very thick",
+                1.6: "ultra thick",
+            }[line_width]
+        except KeyError:
+            # explicit line width
+            return "line width={}pt".format(line_width)
+
+    # The following is an alternative approach to line widths.
+    # The default line width in matplotlib is 1.0pt, in PGFPlots 0.4pt
+    # ('thin').
+    # Match the two defaults, and scale for the rest.
+    scaled_line_width = line_width / 1.0  # scale by default line width
+    try:
+        out = {
+            0.25: "ultra thin",
+            0.5: "very thin",
+            1.0: None,  # default, 'thin'
+            1.5: "semithick",
+            2: "thick",
+            3: "very thick",
+            4: "ultra thick",
+        }[scaled_line_width]
+    except KeyError:
+        # explicit line width
+        out = "line width={}pt".format(0.4 * line_width)
+
+    return out
+
+
+def mpl_linestyle2pgfplots_linestyle(line_style):
+    """Translates a line style of matplotlib to the corresponding style
+    in PGFPlots.
+    """
+    # linestyle is a string or dash tuple. Legal string values are
+    # solid|dashed|dashdot|dotted.  The dash tuple is (offset, onoffseq) where onoffseq
+    # is an even length tuple of on and off ink in points.
+    #
+    # solid: [(None, None), (None, None), ..., (None, None)]
+    # dashed: (0, (6.0, 6.0))
+    # dotted: (0, (1.0, 3.0))
+    # dashdot: (0, (3.0, 5.0, 1.0, 5.0))
+    if isinstance(line_style, tuple):
+        if line_style[0] is None:
+            return None
+
+        if len(line_style[1]) == 2:
+            return "dash pattern=on {}pt off {}pt".format(*line_style[1])
+
+        assert len(line_style[1]) == 4
+        return "dash pattern=on {}pt off {}pt on {}pt off {}pt".format(*line_style[1])
+
+    return {
+        "": None,
+        "None": None,
+        "none": None,  # happens when using plt.boxplot()
+        "-": "solid",
+        "solid": "solid",
+        ":": "dotted",
+        "--": "dashed",
+        "-.": "dash pattern=on 1pt off 3pt on 3pt off 3pt",
+    }[line_style]