Implement line as new style artist

Author: ksunden

data_prototype/artist.py

@@ -1,16 +1,10 @@
 from typing import Sequence
 
-
-import matplotlib.path as mpath
-import matplotlib.colors as mcolors
-import matplotlib.lines as mlines
-import matplotlib.path as mpath
-import matplotlib.transforms as mtransforms
 import numpy as np
 
 from .containers import DataContainer, ArrayContainer, DataUnion
 from .description import Desc, desc_like
-from .conversion_edge import Edge, TransformEdge, FuncEdge, Graph
+from .conversion_edge import Edge, TransformEdge
 
 
 class Artist:
@@ -26,7 +20,8 @@ def __init__(
         edges = edges or []
         self._edges = list(edges)
 
-    def draw(self, renderer, edges: Sequence[Edge]) -> None: ...
+    def draw(self, renderer, edges: Sequence[Edge]) -> None:
+        return
 
 
 class CompatibilityArtist:
@@ -98,72 +93,3 @@ def draw(self, renderer, edges=None):
             )
 
         self._artist.draw(renderer, edges)
-
-
-class Line(Artist):
-    def __init__(self, container, edges=None, **kwargs):
-        super().__init__(container, edges, **kwargs)
-
-        defaults = ArrayContainer(
-            **{
-                "color": "C0",  # TODO: interactions with cycler/rcparams?
-                "linewidth": 1,
-                "linestyle": "-",
-            }
-        )
-
-        self._container = DataUnion(defaults, self._container)
-        # These are a stand-in for units etc... just kind of placed here as no-ops
-        self._edges += [
-            FuncEdge.from_func(
-                "xvals", lambda x: x, "naive", "data", inverse=lambda x: x
-            ),
-            FuncEdge.from_func(
-                "yvals", lambda y: y, "naive", "data", inverse=lambda y: y
-            ),
-        ]
-
-    def draw(self, renderer, edges: Sequence[Edge]) -> None:
-        g = Graph(list(edges) + self._edges)
-        desc = Desc(("N",), np.dtype("f8"), "display")
-        xy = {"x": desc, "y": desc}
-        conv = g.evaluator(self._container.describe(), xy)
-        query, _ = self._container.query(g)
-        x, y = conv.evaluate(query).values()
-
-        # make the Path object
-        path = mpath.Path(np.vstack([x, y]).T)
-        # make an configure the graphic context
-        gc = renderer.new_gc()
-        gc.set_foreground(mcolors.to_rgba(query["color"]), isRGBA=True)
-        gc.set_linewidth(query["linewidth"])
-        gc.set_dashes(*mlines._get_dash_pattern(query["linestyle"]))
-        # add the line to the render buffer
-        renderer.draw_path(gc, path, mtransforms.IdentityTransform())
-
-
-class Image(Artist):
-    def __init__(self, container, edges=None, **kwargs):
-        super().__init__(container, edges, **kwargs)
-
-        defaults = ArrayContainer(
-            **{
-                "cmap": "viridis",
-                "norm": "linear",
-            }
-        )
-
-        self._container = DataUnion(defaults, self._container)
-        # These are a stand-in for units etc... just kind of placed here as no-ops
-        self._edges += [
-            FuncEdge.from_func(
-                "xvals", lambda x: x, "naive", "data", inverse=lambda x: x
-            ),
-            FuncEdge.from_func(
-                "yvals", lambda y: y, "naive", "data", inverse=lambda y: y
-            ),
-        ]
-
-    def draw(self, renderer, edges: Sequence[Edge]) -> None:
-        g = Graph(list(edges) + self._edges)
-        ...

data_prototype/line.py

@@ -0,0 +1,123 @@
+from typing import Sequence
+
+import matplotlib.path as mpath
+import matplotlib.colors as mcolors
+import matplotlib.lines as mlines
+import matplotlib.markers as mmarkers
+import matplotlib.transforms as mtransforms
+import numpy as np
+
+from .artist import Artist
+from .description import Desc
+from .conversion_edge import Edge, Graph, CoordinateEdge, DefaultEdge
+
+
+class Line(Artist):
+    def __init__(self, container, edges=None, **kwargs):
+        super().__init__(container, edges, **kwargs)
+
+        colordesc = Desc((), str, "display")  # ... this needs thinking...
+        floatdesc = Desc((), float, "display")
+        strdesc = Desc((), str, "display")
+
+        self._edges += [
+            CoordinateEdge.from_coords("xycoords", {"x": "auto", "y": "auto"}, "data"),
+            CoordinateEdge.from_coords("color", {"color": Desc((), str)}, "display"),
+            CoordinateEdge.from_coords(
+                "linewidth", {"linewidth": Desc((), np.dtype("f8"))}, "display"
+            ),
+            CoordinateEdge.from_coords(
+                "linestyle", {"linestyle": Desc((), str)}, "display"
+            ),
+            CoordinateEdge.from_coords(
+                "markeredgecolor", {"markeredgecolor": Desc((), str)}, "display"
+            ),
+            CoordinateEdge.from_coords(
+                "markerfacecolor", {"markerfacecolor": Desc((), str)}, "display"
+            ),
+            CoordinateEdge.from_coords(
+                "markersize", {"markersize": Desc((), float)}, "display"
+            ),
+            CoordinateEdge.from_coords(
+                "markeredgewidth", {"markeredgewidth": Desc((), float)}, "display"
+            ),
+            CoordinateEdge.from_coords("marker", {"marker": Desc((), str)}, "display"),
+            DefaultEdge.from_default_value("color_def", "color", colordesc, "C0"),
+            DefaultEdge.from_default_value("linewidth_def", "linewidth", floatdesc, 1),
+            DefaultEdge.from_default_value("linestyle_def", "linestyle", strdesc, "-"),
+            DefaultEdge.from_default_value(
+                "mec_def", "markeredgecolor", colordesc, "C0"
+            ),
+            DefaultEdge.from_default_value(
+                "mfc_def", "markerfacecolor", colordesc, "C0"
+            ),
+            DefaultEdge.from_default_value("ms_def", "markersize", floatdesc, 6),
+            DefaultEdge.from_default_value("mew_def", "markeredgewidth", floatdesc, 1),
+            DefaultEdge.from_default_value("marker_def", "marker", strdesc, "None"),
+        ]
+        # Currently ignoring:
+        # - cap/join style
+        # - url
+        # - antialiased
+        # - snapping
+        # - sketch
+        # - gap color
+        # - draw style (steps)
+        # - fill style/alt_marker_path
+        # - markevery
+        # - non-str markers
+        # Each individually pretty easy, but relatively rare features, focusing on common cases
+
+    def draw(self, renderer, edges: Sequence[Edge]) -> None:
+        g = Graph(list(edges) + self._edges)
+        desc = Desc(("N",), np.dtype("f8"), "display")
+        colordesc = Desc((), str, "display")  # ... this needs thinking...
+        floatdesc = Desc((), float, "display")
+        strdesc = Desc((), str, "display")
+
+        require = {
+            "x": desc,
+            "y": desc,
+            "color": colordesc,
+            "linewidth": floatdesc,
+            "linestyle": strdesc,
+            "markeredgecolor": colordesc,
+            "markerfacecolor": colordesc,
+            "markersize": floatdesc,
+            "markeredgewidth": floatdesc,
+            "marker": strdesc,
+        }
+
+        conv = g.evaluator(self._container.describe(), require)
+        query, _ = self._container.query(g)
+        x, y, color, lw, ls, *marker = conv.evaluate(query).values()
+        mec, mfc, ms, mew, mark = marker
+
+        # make the Path object
+        path = mpath.Path(np.vstack([x, y]).T)
+        # make an configure the graphic context
+        gc = renderer.new_gc()
+        gc.set_foreground(color)
+        gc.set_linewidth(lw)
+        gc.set_dashes(*mlines._scale_dashes(*mlines._get_dash_pattern(ls), lw))
+        # add the line to the render buffer
+        renderer.draw_path(gc, path, mtransforms.IdentityTransform())
+
+        if mark != "None" and ms > 0:
+            gc = renderer.new_gc()
+            gc.set_linewidth(mew)
+            gc.set_foreground(mec)
+            marker_ = mmarkers.MarkerStyle(mark)
+            marker_path = marker_.get_path()
+            marker_trans = marker_.get_transform()
+            w = renderer.points_to_pixels(ms)
+            marker_trans = marker_trans.scale(w)
+            mfc = mcolors.to_rgba(mfc)
+            renderer.draw_markers(
+                gc,
+                marker_path,
+                marker_trans,
+                path,
+                mtransforms.IdentityTransform(),
+                mfc,
+            )

examples/first.py

@@ -11,15 +11,24 @@
 import numpy as np
 import pandas as pd
 
-from data_prototype.artist import Line, CompatibilityArtist
+from data_prototype.artist import CompatibilityArtist
+from data_prototype.line import Line
 from data_prototype.containers import FuncContainer, SeriesContainer
 
 fc = FuncContainer({"x": (("N",), lambda x: x), "y": (("N",), np.sin)})
 lw = Line(fc, linewidth=5, color="green", label="sin (function)")
 
 th = np.linspace(0, 2 * np.pi, 16)
 sc = SeriesContainer(pd.Series(index=th, data=np.cos(th)), index_name="x", col_name="y")
-lw2 = Line(sc, linewidth=3, linestyle=":", color="blue", label="cos (pandas)")
+lw2 = Line(
+    sc,
+    linewidth=3,
+    linestyle=":",
+    color="C0",
+    label="cos (pandas)",
+    marker=".",
+    markersize=12,
+)
 
 fig, ax = plt.subplots()
 ax.add_artist(CompatibilityArtist(lw))

examples/mapped.py

@@ -12,29 +12,46 @@
 
 from matplotlib.colors import Normalize
 
-from data_prototype.wrappers import LineWrapper, FormattedText
+from data_prototype.wrappers import FormattedText
+from data_prototype.artist import CompatibilityArtist as CA
+from data_prototype.line import Line
 from data_prototype.containers import ArrayContainer
+from data_prototype.description import Desc
 from data_prototype.conversion_node import FunctionConversionNode
+from data_prototype.conversion_edge import FuncEdge
+
 
 cmap = plt.colormaps["viridis"]
 cmap.set_over("k")
 cmap.set_under("r")
 norm = Normalize(1, 8)
 
-line_converter = FunctionConversionNode.from_funcs(
-    {
-        # arbitrary functions
-        "lw": lambda lw: min(1 + lw, 5),
-        # standard color mapping
-        "color": lambda j: cmap(norm(j)),
-        # categorical
-        "ls": lambda cat: {"A": "-", "B": ":", "C": "--"}[cat[()]],
-    },
-)
+line_edges = [
+    FuncEdge.from_func(
+        "lw",
+        lambda lw: min(1 + lw, 5),
+        {"lw": Desc((), str, "auto")},
+        {"linewidth": Desc((), str, "display")},
+    ),
+    # Probably should separate out norm/cmap step
+    # Slight lie about color being a string here, because of limitations in impl
+    FuncEdge.from_func(
+        "cmap",
+        lambda j: cmap(norm(j)),
+        {"j": Desc((), str, "auto")},
+        {"color": Desc((), str, "display")},
+    ),
+    FuncEdge.from_func(
+        "ls",
+        lambda cat: {"A": "-", "B": ":", "C": "--"}[cat],
+        {"cat": Desc((), str, "auto")},
+        {"linestyle": Desc((), str, "display")},
+    ),
+]
 
 text_converter = FunctionConversionNode.from_funcs(
     {
-        "text": lambda j, cat: f"index={j[()]} class={cat[()]!r}",
+        "text": lambda j, cat: f"index={j[()]} class={cat!r}",
         "y": lambda j: j,
         "x": lambda x: 2 * np.pi,
     },
@@ -53,13 +70,15 @@
             "y": np.sin(th + j * delta) + j,
             "j": np.asarray(j),
             "lw": np.asarray(j),
-            "cat": np.asarray({0: "A", 1: "B", 2: "C"}[j % 3]),
+            "cat": {0: "A", 1: "B", 2: "C"}[j % 3],
         }
     )
     ax.add_artist(
-        LineWrapper(
-            ac,
-            line_converter,
+        CA(
+            Line(
+                ac,
+                line_edges,
+            )
         )
     )
     ax.add_artist(

examples/widgets.py

@@ -14,8 +14,10 @@
 import matplotlib.pyplot as plt
 from matplotlib.widgets import Slider, Button
 
-from data_prototype.artist import Line, CompatibilityArtist as CA
+from data_prototype.artist import CompatibilityArtist as CA
+from data_prototype.line import Line
 from data_prototype.containers import FuncContainer
+from data_prototype.description import Desc
 from data_prototype.conversion_edge import FuncEdge
 
 
@@ -126,11 +128,12 @@ def _query_hash(self, graph, parent_coordinates):
         FuncEdge.from_func(
             "color",
             lambda color: cmap((color / (2 * np.pi)) % 1),
-            "user",
-            "display",
+            {"color": Desc((1,), np.float64)},
+            {"color": Desc((), np.float64, "display")},
         )
     ],
-    linewidth=5,
+    linewidth=5.0,
+    linestyle="-",
 )
 ax.add_artist(CA(lw))