Redesign Markers and wide lines classes (#134)

Fixes #133

Author: corranwebster

docs/source/user_guide/tutorial.rst

@@ -468,8 +468,8 @@ for each point and what to display at each point.  This can be:
 - a :py:class:`framebuf.FrameBuffer` containing a 1-bit image
 - a :py:class:`array` of 16-bit integers giving a polygon to fill
 
-The |Markers| shape expects a geometry consisting of an x, y point and a
-marker size, the colors for each marker and the shape of each marker.
+The |Markers| shape expects a geometry consisting of an x, y point, the colors
+for each marker, the size of each marker, and the shape of each marker.
 The marker shapes can be specified in the same way as |Points| (which are
 not scaled by size), but additionally as constants :py:attr:`Marker.CIRCLE`,
 :py:attr:`Marker.SQUARE`, etc. which will be scaled according to the sizes.
@@ -1011,10 +1011,10 @@ markers and text giving the corresponding values::
             [
                 Repeat(x1 + 30),
                 Range(cy + 74, cy + 114, 12),
-                humidity_scale.scale_values(sample_humidities),
             ]
         ),
         colors.blue,
+        humidity_scale.scale_values(sample_humidities),
         Marker.CIRCLE,
     )
     surface.markers(
@@ -1023,10 +1023,10 @@ markers and text giving the corresponding values::
             [
                 Repeat(x1 + 40),
                 Range(cy + 75, cy + 115, 12),
-                humidity_scale.scale_values(sample_humidities),
             ]
         ),
         colors.grey_a,
+        humidity_scale.scale_values(sample_humidities),
         [f"{h}%" for h in sample_humidities],
     )
 

examples/lines_example.py

@@ -39,9 +39,10 @@
 # draw some lines
 lines = WideLines(
     ColumnGeometry(
-        [Range(8, 96, 8), Repeat(20), Range(8, 184, 16), Repeat(100), Range(1, 11)]
+        [Range(8, 96, 8), Repeat(20), Range(8, 184, 16), Repeat(100)]
     ),
     Interpolated(viridis, 10),
+    Range(1, 11),
     clip=(0, 0, 160, 120),
 )
 surface.add_shape(DRAWING, lines)
@@ -55,10 +56,10 @@
             Repeat(100),
             Range(8, 184, 16) + 160,
             Repeat(20),
-            Range(1, 11),
         ]
     ),
     Interpolated(viridis, 10),
+    Range(1, 11),
     clip=(160, 0, 160, 120),
     round=False,
 )
@@ -82,12 +83,12 @@
                     10 + 30 * i,
                     125,
                 ]
-                + [i + 1],
             )
             for i in range(10)
         ]
     ),
     Interpolated(viridis, 10),
+    Range(1, 11),
     clip=(0, 120, 320, 120),
 )
 surface.add_shape(DRAWING, polylines)

examples/polar_example.py

@@ -131,22 +131,18 @@
 )
 surface.add_shape(DRAWING, radar)
 markers = Markers(
-    Extend(
-        [
-            polar_points(
-                196,
-                64,
-                ColumnGeometry(
-                    [
-                        [30, 15, 45, 5, 45, 60],
-                        Range(0, 360, 60),
-                    ]
-                ),
-            ),
-            ColumnGeometry([Repeat(12)]),
-        ]
+    polar_points(
+        196,
+        64,
+        ColumnGeometry(
+            [
+                [30, 15, 45, 5, 45, 60],
+                Range(0, 360, 60),
+            ]
+        ),
     ),
     Repeat(grey_3),
+    Repeat(12),
     [f" {x}" for x in [6, 3, 9, 1, 9, 12]],
     clip=(0, 0, 320, 240),
 )

examples/scatter_plot_example.py

@@ -181,13 +181,14 @@ def scale_values(self, data):
 marker_colors = time_scale.scale_values(timestamps)
 
 # Create point-size geometry for the data points
-markers = ColumnGeometry([xs, ys, marker_sizes])
+markers = ColumnGeometry([xs, ys])
 
 # draw the plot
 surface.markers(
     DRAWING,
     markers,
     marker_colors,
+    marker_sizes,
     Repeat(Marker.CIRCLE),
     clip=(x, y, w, h),
 )
@@ -272,10 +273,10 @@ def scale_values(self, data):
         [
             Repeat(x1 + 30),
             Range(cy + 74, cy + 114, 12),
-            humidity_scale.scale_values(sample_humidities),
         ]
     ),
     Repeat(colors.blue),
+    humidity_scale.scale_values(sample_humidities),
     Repeat(Marker.CIRCLE),
 )
 surface.markers(
@@ -284,10 +285,10 @@ def scale_values(self, data):
         [
             Repeat(x1 + 40),
             Range(cy + 75, cy + 115, 12),
-            humidity_scale.scale_values(sample_humidities),
         ]
     ),
     Repeat(colors.grey_a),
+    humidity_scale.scale_values(sample_humidities),
     [f"{h}%" for h in sample_humidities],
     clip=(x1 + 30, cy + 70, 40, 48),
 )

examples/shapes_example.py

@@ -115,7 +115,7 @@
             16 + x + int((16 - 8 * (a % 2)) * math.sin(math.pi * a / 5)),
             160 - int((16 - 8 * (a % 2)) * math.cos(math.pi * a / 5)),
         )
-        for a in range(10)
+        for a in range(11)
     ]
     for x in range(0, 128, 32)
 ]
@@ -194,10 +194,10 @@
         [
             Range(160, 320, 16),
             Repeat(30),
-            Range(1, 13, 1),
         ]
     ),
     Interpolated(viridis, 10),
+    Range(1, 13, 1),
     [
         Marker.PIXEL,
         Marker.CIRCLE,

src/tempe/component.py

@@ -289,15 +289,16 @@ def map_xy(self):
             xs[i] = int(x)
             ys[i] = int(y)
 
-        return xs, ys, self.sizes
+        return xs, ys
 
     def draw(self):
         super().draw()
-        xs, ys, sizes = self.map_xy()
+        xs, ys = self.map_xy()
         self.shapes["markers"] = self.surface.points(
             DRAWING,
-            ColumnGeometry([xs, ys, sizes]),
+            ColumnGeometry([xs, ys]),
             self.colors,
+            self.sizes,
             self.markers,
             clip=self.bounds,
         )

src/tempe/lines.py

@@ -5,18 +5,18 @@
 from array import array
 from math import sqrt
 
-from .shapes import ColoredGeometry
+from .shapes import SizedGeometry
 from .util import line_points, intersect_poly_rect
 
 
-class WideLines(ColoredGeometry):
+class WideLines(SizedGeometry):
     """Render multiple colored line segments with variable width.
 
     Geometry should produce x0, y0, x1, y1, width arrays.
     """
 
-    def __init__(self, geometry, colors, *, round=True, surface=None, clip=None):
-        super().__init__(geometry, colors, surface=surface, clip=clip)
+    def __init__(self, geometry, colors, sizes, *, round=True, surface=None, clip=None):
+        super().__init__(geometry, colors, sizes, surface=surface, clip=clip)
         self.round = round
 
     def draw_raster(self, raster):
@@ -27,8 +27,7 @@ def draw_raster(self, raster):
         h = raster.h
         vertices = array("h", bytearray(16))
         should_round = self.round
-        for geometry, color in self:
-            lw = geometry[4]
+        for geometry, color, lw in self:
             if intersect_poly_rect(geometry[:4], 4, x - lw, y - lw, w + 2 * lw, h + 2 * lw):
                 x0 = geometry[0]
                 y0 = geometry[1]
@@ -50,19 +49,17 @@ def _get_bounds(self):
         min_x = 0x7FFF
         max_y = -0x7FFF
         min_y = 0x7FFF
-        for geometry in self.geometry:
-            max_x = max(max_x, geometry[0] + geometry[4], geometry[2] + geometry[4])
-            min_x = min(min_x, geometry[0] - geometry[4], geometry[2] - geometry[4])
-            max_y = max(max_y, geometry[1] + geometry[4], geometry[3] + geometry[4])
-            min_y = min(min_y, geometry[1] - geometry[4], geometry[3] - geometry[4])
+        for geometry, w in zip(self.geometry, self.sizes):
+            max_x = max(max_x, geometry[0] + w, geometry[2] + w)
+            min_x = min(min_x, geometry[0] - w, geometry[2] - w)
+            max_y = max(max_y, geometry[1] + w, geometry[3] + w)
+            min_y = min(min_y, geometry[1] - w, geometry[3] - w)
 
         return (min_x, min_y, max_x - min_x, max_y - min_y)
 
 
-class WidePolyLines(ColoredGeometry):
+class WidePolyLines(SizedGeometry):
     """Render multiple colored polylines with variable width.
-
-    Geometry should produce array of [x0, y0, x1, y1, ...] and width.
     """
 
     def draw_raster(self, raster):
@@ -72,9 +69,7 @@ def draw_raster(self, raster):
         w = raster.w
         h = raster.h
         vertices = array("h", bytearray(16))
-        for geometry, color in self:
-            lw = geometry[-1]
-            lines = geometry[:-1]
+        for lines, color, lw in self:
             if intersect_poly_rect(lines, len(lines), x - lw, y - lw, w + 2 * lw, h + 2 * lw):
                 for i in range(0, len(lines) - 2, 2):
                     x0 = lines[i]
@@ -99,9 +94,7 @@ def _get_bounds(self):
         min_x = 0x7FFF
         max_y = -0x7FFF
         min_y = 0x7FFF
-        for geometry in self.geometry:
-            w = geometry[-1]
-            lines = geometry[:-1]
+        for lines, w in zip(self.geometry, self.sizes):
             for i in range(0, len(lines), 2):
                 max_x = max(max_x, lines[i] + w)
                 min_x = min(min_x, lines[i] - w)

src/tempe/lines.pyi

@@ -20,17 +20,16 @@ by rendering circles at the vertices.
 from array import array
 from collections.abc import Sequence, Iterable
 from math import sqrt
-from typing import TypeAlias
+from typing import Generator, TypeAlias
 
-from .shapes import ColoredGeometry, point_array, rectangle
+from .shapes import SizedGeometry, point_array, rectangle, points
 from .colors import rgb565
 
-points_widths: TypeAlias = tuple[int, int, int, int, int]
 
-class WideLines(ColoredGeometry[points_widths]):
+class WideLines(SizedGeometry[points]):
     """Render multiple colored line segments with variable width.
 
-    Geometry should produce x0, y0, x1, y1, width arrays.
+    Geometry should produce x0, y0, x1, y1 arrays.
 
     For line widths less than 2, this renders using the standard framebuf
     line drawing routines.  For line widths of 2 or more, this renders each
@@ -40,9 +39,11 @@ class WideLines(ColoredGeometry[points_widths]):
     Parameters
     ----------
     geometry : Iterable[geom]
-        The sequence of geometries to render.
+        The sequence of line segments to render.
     colors : Iterable[rgb565]
-        The sequence of colors for each geometry.
+        The sequence of colors for each line segment.
+    sizes : Iterable[rgb565]
+        The sequence of line widths for each line segment.
     round : bool
         Whether to round the ends with circles, or to leave as a flat end.
     surface : Surface | None
@@ -54,19 +55,18 @@ class WideLines(ColoredGeometry[points_widths]):
 
     def __init__(
         self,
-        geometry: Iterable[points_widths],
+        geometry: Iterable[points],
         colors: Iterable[rgb565],
         *,
         round: bool = True,
         surface: "tempe.surface.Surface | None" = None,
         clip: rectangle | None = None,
     ): ...
-    def __iter__(self) -> tuple[points_widths, int]: ...
 
-class WidePolyLines(ColoredGeometry[point_array]):
+class WidePolyLines(SizedGeometry[point_array]):
     """Render multiple colored polylines with variable width.
 
-    Geometry should produce array of [x0, y0, x1, y1, ..., width].
+    Geometry should produce array of [x0, y0, x1, y1, ...].
 
     For line widths less than 2, this renders using the standard framebuf
     line drawing routines.  For line widths of 2 or more, this renders each