Initial impementation of text

Author: ksunden

data_prototype/artist.py

@@ -277,7 +277,10 @@ def axes(self, ax):
             return
 
         desc: Desc = Desc(("N",), coordinates="data")
+        desc_scal: Desc = Desc((), coordinates="data")
         xy: dict[str, Desc] = {"x": desc, "y": desc}
+        xy_scal: dict[str, Desc] = {"x": desc_scal, "y": desc_scal}
+
         self._graph = Graph(
             [
                 TransformEdge(
@@ -292,6 +295,18 @@ def axes(self, ax):
                     desc_like(xy, coordinates="display"),
                     transform=self._axes.transAxes,
                 ),
+                TransformEdge(
+                    "data_scal",
+                    xy_scal,
+                    desc_like(xy_scal, coordinates="axes"),
+                    transform=self._axes.transData - self._axes.transAxes,
+                ),
+                TransformEdge(
+                    "axes_scal",
+                    desc_like(xy_scal, coordinates="axes"),
+                    desc_like(xy_scal, coordinates="display"),
+                    transform=self._axes.transAxes,
+                ),
                 FuncEdge.from_func(
                     "xunits",
                     lambda: self._axes.xaxis.units,

data_prototype/conversion_edge.py

@@ -327,6 +327,7 @@ def edges(self):
                 import matplotlib.pyplot as plt
 
                 self.visualize(input)
+                self.visualize()
                 plt.show()
                 raise NotImplementedError(
                     "This may be possible, but is not a simple case already considered"
@@ -344,7 +345,7 @@ def edges(self):
             else:
                 out_edges.append(SequenceEdge.from_edges("eval", edges, output_subset))
 
-        found_outputs = set()
+        found_outputs = set(input)
         for out in out_edges:
             found_outputs |= set(out.output)
         if missing := set(output) - found_outputs:

data_prototype/text.py

@@ -0,0 +1,85 @@
+import numpy as np
+
+
+from .artist import Artist
+from .description import Desc
+from .conversion_edge import Graph, CoordinateEdge
+
+
+class Text(Artist):
+    def __init__(self, container, edges=None, **kwargs):
+        super().__init__(container, edges, **kwargs)
+
+        edges = [
+            CoordinateEdge.from_coords(
+                "xycoords", {"x": Desc((), "auto"), "y": Desc((), "auto")}, "data"
+            ),
+        ]
+
+        self._graph = self._graph + Graph(edges)
+
+    def draw(self, renderer, graph: Graph) -> None:
+        if not self.get_visible():
+            return
+        g = graph + self._graph
+        conv = g.evaluator(
+            self._container.describe(),
+            {
+                "x": Desc((), "display"),
+                "y": Desc((), "display"),
+                "text": Desc((), "display"),
+                "color": Desc((4,), "rgba"),
+                "alpha": Desc((), "display"),
+                "fontproperties": Desc((), "display"),
+                "usetex": Desc((), "display"),
+                # "parse_math": Desc((), "display"),
+                # "wrap": Desc((), "display"),
+                # "verticalalignment": Desc((), "display"),
+                # "horizontalalignment": Desc((), "display"),
+                "rotation": Desc((), "display"),
+                # "linespacing": Desc((), "display"),
+                # "rotation_mode": Desc((), "display"),
+                "antialiased": Desc((), "display"),
+            },
+        )
+
+        query, _ = self._container.query(g)
+        evald = conv.evaluate(query)
+
+        text = evald["text"]
+        if text == "":
+            return
+
+        x = evald["x"]
+        y = evald["y"]
+
+        if not np.isfinite(x) or not np.isfinite(y):
+            # TODO: log?
+            return
+
+        # TODO bbox?
+        # TODO implement wrapping/layout?
+        # TODO implement math?
+        # TODO implement path_effects?
+
+        # TODO gid?
+        renderer.open_group("text", None)
+
+        gc = renderer.new_gc()
+        gc.set_foreground(evald["color"])
+        gc.set_alpha(evald["alpha"])
+        # TODO url?
+        gc.set_antialiased(evald["antialiased"])
+        # TODO clipping?
+
+        if evald["usetex"]:
+            renderer.draw_tex(
+                gc, x, y, text, evald["fontproperties"], evald["rotation"]
+            )
+        else:
+            renderer.draw_text(
+                gc, x, y, text, evald["fontproperties"], evald["rotation"]
+            )
+
+        gc.restore()
+        renderer.close_group("text")

examples/animation.py

@@ -16,15 +16,16 @@
 
 import matplotlib.pyplot as plt
 from matplotlib.animation import FuncAnimation
+from matplotlib.font_manager import FontProperties
 
 from data_prototype.conversion_edge import Graph
 from data_prototype.description import Desc
 
-from data_prototype.conversion_node import FunctionConversionNode
 
-from data_prototype.wrappers import FormattedText
-from data_prototype.artist import CompatibilityArtist as CA
+from data_prototype.artist import CompatibilityAxes
 from data_prototype.line import Line
+from data_prototype.text import Text
+from data_prototype.conversion_edge import FuncEdge
 
 
 class SinOfTime:
@@ -38,6 +39,12 @@ def describe(self):
             "y": Desc((self.N,)),
             "phase": Desc(()),
             "time": Desc(()),
+            "rotation": Desc((), "display"),
+            "alpha": Desc((), "display"),
+            "color": Desc((4,), "rgba"),
+            "usetex": Desc((), "display"),
+            "antialiased": Desc((), "display"),
+            "fontproperties": Desc((), "display"),
         }
 
     def query(
@@ -55,6 +62,12 @@ def query(
             "y": np.sin(th + phase),
             "phase": phase,
             "time": cur_time,
+            "rotation": 0,
+            "alpha": 1,
+            "color": np.array([0, 0, 0, 1]),
+            "usetex": False,
+            "antialiased": True,
+            "fontproperties": FontProperties(),
         }, hash(cur_time)
 
 
@@ -63,15 +76,24 @@ def update(frame, art):
 
 
 sot_c = SinOfTime()
-lw = CA(Line(sot_c, linewidth=5, color="green", label="sin(time)"))
-fc = FormattedText(
+lw = Line(sot_c, linewidth=5, color="green", label="sin(time)")
+fc = Text(
     sot_c,
-    FunctionConversionNode.from_funcs(
-        {"text": lambda phase: f"ϕ={phase:.2f}", "x": lambda: 2 * np.pi, "y": lambda: 1}
-    ),
+    [
+        FuncEdge.from_func(
+            "text",
+            lambda phase: f"ϕ={phase:.2f}",
+            {"phase": Desc((), "auto")},
+            {"text": Desc((), "display")},
+        ),
+    ],
+    x=2 * np.pi,
+    y=0,
     ha="right",
 )
-fig, ax = plt.subplots()
+fig, nax = plt.subplots()
+ax = CompatibilityAxes(nax)
+nax.add_artist(ax)
 ax.add_artist(lw)
 ax.add_artist(fc)
 ax.set_xlim(0, 2 * np.pi)