Change Sparkline to use polygon

Previous implementation used multiple Line elements, causing unnecessary memory overhead

Author: matemaciek

adafruit_display_shapes/sparkline.py

@@ -25,7 +25,7 @@
 Various common shapes for use with displayio - Sparkline!
 
 
-* Author(s): Kevin Matocha, Maciej Sokołowski
+* Author(s): Kevin Matocha
 
 Implementation Notes
 --------------------
@@ -44,7 +44,7 @@
 except ImportError:
     pass
 import displayio
-from adafruit_display_shapes.line import Line
+from adafruit_display_shapes.polygon import Polygon
 
 
 class _CyclicBuffer():
@@ -62,23 +62,13 @@ def push(self, value: float) -> None:
     def pop(self) -> float:
         if self.len() == 0:
             raise RuntimeError("Trying to pop from empty buffer")
-        result = self.first()
+        result = self._buffer[self._start]
         self._start += 1
         if self._start == len(self._buffer):
             self._start -= len(self._buffer)
             self._end -= len(self._buffer)
         return result
 
-    def first(self) -> float:
-        if self.len() == 0:
-            return None
-        return self._buffer[self._start]
-        
-    def last(self) -> float:
-        if self.len() == 0:
-            return None
-        return self._buffer[(self._end - 1) % len(self._buffer)]
-        
     def len(self) -> int:
         return self._end - self._start
 
@@ -147,18 +137,17 @@ def __init__(
         self.y_top = y_max
         # y_top: The actual minimum value of the vertical scale, will be
         # updated if autorange
-        self._redraw = True  # _redraw: redraw primitives
-        self._last = []  # _last: last point of sparkline
+        self._points = []  # _points: all points of sparkline
 
-        super().__init__(x=x, y=y)  # self is a group of lines
+        super().__init__(x=x, y=y)  # self is a group of single Polygon
+                                    # (TODO: it has one element, maybe group is no longer needed?)
 
     def clear_values(self) -> None:
         """Clears _buffer and removes all lines in the group"""
 
         for _ in range(len(self)):  # remove all items from the current group
             self.pop()
         self._buffer.clear()
-        self._redraw = True
 
     def add_value(self, value: float, update: bool = True) -> None:
         """Add a value to the sparkline.
@@ -181,16 +170,13 @@ def add_value(self, value: float, update: bool = True) -> None:
                     self.y_bottom = min(self._buffer.values())
                 if self.y_max is None and first == self.y_top:
                     self.y_top = max(self._buffer.values())
-                self._redraw = True
             self._buffer.push(value)
 
             if self.y_min is None:
-                self._redraw = self._redraw or value < self.y_bottom
                 self.y_bottom = (
                     value if not self.y_bottom else min(value, self.y_bottom)
                 )
             if self.y_max is None:
-                self._redraw = self._redraw or value > self.y_top
                 self.y_top = value if not self.y_top else max(value, self.y_top)
 
             if update:
@@ -218,25 +204,23 @@ def _xintercept(
             ) / slope  # calculate the x-intercept at position y=horizontalY
             return int(xint)
 
-    def _plotline(
+    def _add_point(
         self,
-        x_1: int,
-        last_value: float,
-        x_2: int,
+        x: int,
         value: float,
     ) -> None:
 
         # Guard for y_top and y_bottom being the same
         if self.y_top == self.y_bottom:
-            y_2 = int(0.5 * self.height)
-            y_1 = int(0.5 * self.height)
+            y = int(0.5 * self.height)
         else:
-            y_2 = int(self.height * (self.y_top - value) / (self.y_top - self.y_bottom))
-            y_1 = int(
-                self.height * (self.y_top - last_value) / (self.y_top - self.y_bottom)
-            )
-        self.append(Line(x_1, y_1, x_2, y_2, self.color))  # plot the line
-        self._last = [x_2, value]
+            y = int(self.height * (self.y_top - value) / (self.y_top - self.y_bottom))
+        self._points.append((x, y))
+        
+    def _draw(self) -> None:
+        while(len(self)):
+            self.pop()
+        self.append(Polygon(self._points, outline=self.color, close=False))  # plot the polyline
 
     # pylint: disable= too-many-branches, too-many-nested-blocks, too-many-locals, too-many-statements
 
@@ -246,42 +230,27 @@ def update(self) -> None:
         # bail out early if we only have a single point
         n_points = self._buffer.len()
         if n_points < 2:
-            self._last = [0, self._buffer.first()]
             return
 
         if self.dyn_xpitch:
             # this is a float, only make int when plotting the line
             xpitch = (self.width - 1) / (n_points - 1)
-            self._redraw = True
         else:
             xpitch = self._xpitch
 
-        # only add new segment if redrawing is not necessary
-        if not self._redraw:
-            # end of last line (last point, read as "x(-1)")
-            x_m1 = self._last[0]
-            y_m1 = self._last[1]
-            # end of new line (new point, read as "x(0)")
-            x_0 = int(x_m1 + xpitch)
-            y_0 = self._buffer.last()
-            self._plotline(x_m1, y_m1, x_0, y_0)
-            return
-
-        self._redraw = False  # reset, since we now redraw everything
-        for _ in range(len(self)):  # remove all items from the current group
-            self.pop()
+        self._points = []  # remove all points
 
         for count, value in enumerate(self._buffer.values()):
             if count == 0:
-                pass  # don't draw anything for a first point
+                self._add_point(0, value)
             else:
-                x_2 = int(xpitch * count)
-                x_1 = int(xpitch * (count - 1))
+                x = int(xpitch * count)
+                last_x = int(xpitch * (count - 1))
 
                 if (self.y_bottom <= last_value <= self.y_top) and (
                     self.y_bottom <= value <= self.y_top
                 ):  # both points are in range, plot the line
-                    self._plotline(x_1, last_value, x_2, value)
+                    self._add_point(x, value)
 
                 else:  # at least one point is out of range, clip one or both ends the line
                     if ((last_value > self.y_top) and (value > self.y_top)) or (
@@ -291,45 +260,34 @@ def update(self) -> None:
                         pass
                     else:
                         xint_bottom = self._xintercept(
-                            x_1, last_value, x_2, value, self.y_bottom
+                            last_x, last_value, x, value, self.y_bottom
                         )  # get possible new x intercept points
                         xint_top = self._xintercept(
-                            x_1, last_value, x_2, value, self.y_top
+                            last_x, last_value, x, value, self.y_top
                         )  # on the top and bottom of range
                         if (xint_bottom is None) or (
                             xint_top is None
                         ):  # out of range doublecheck
                             pass
                         else:
                             # Initialize the adjusted values as the baseline
-                            adj_x_1 = x_1
-                            adj_last_value = last_value
-                            adj_x_2 = x_2
+                            adj_x = x
                             adj_value = value
 
                             if value > last_value:  # slope is positive
-                                if xint_bottom >= x_1:  # bottom is clipped
-                                    adj_x_1 = xint_bottom
-                                    adj_last_value = self.y_bottom  # y_1
-                                if xint_top <= x_2:  # top is clipped
-                                    adj_x_2 = xint_top
-                                    adj_value = self.y_top  # y_2
+                                if xint_top <= x:  # top is clipped
+                                    adj_x = xint_top
+                                    adj_value = self.y_top  # y
                             else:  # slope is negative
-                                if xint_top >= x_1:  # top is clipped
-                                    adj_x_1 = xint_top
-                                    adj_last_value = self.y_top  # y_1
-                                if xint_bottom <= x_2:  # bottom is clipped
-                                    adj_x_2 = xint_bottom
-                                    adj_value = self.y_bottom  # y_2
-
-                            self._plotline(
-                                adj_x_1,
-                                adj_last_value,
-                                adj_x_2,
-                                adj_value,
-                            )
+                                if xint_bottom <= x:  # bottom is clipped
+                                    adj_x = xint_bottom
+                                    adj_value = self.y_bottom  # y
+
+                            self._add_point(adj_x, adj_value)
 
             last_value = value  # store value for the next iteration
+        
+        self._draw()
 
     def values(self) -> List[float]:
         """Returns the values displayed on the sparkline."""