adding filled polygon. Add support for stroke on Polygon

Author: FoamyGuy

adafruit_display_shapes/filled_polygon.py

@@ -0,0 +1,142 @@
+# SPDX-FileCopyrightText: 2024 Tim Cocks for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+"""
+`filled_polygon`
+================================================================================
+
+Various common shapes for use with displayio - Polygon that supports
+both fill and outline
+
+
+* Author(s): Bernhard Bablok, Tim Cocks
+
+Implementation Notes
+--------------------
+
+**Software and Dependencies:**
+
+* Adafruit CircuitPython firmware for the supported boards:
+ https://github.com/adafruit/circuitpython/releases
+
+"""
+
+try:
+ from typing import Optional, List, Tuple
+except ImportError:
+ pass
+
+import displayio
+from adafruit_display_shapes.polygon import Polygon
+
+try:
+ import vectorio
+
+ HAVE_VECTORIO = True
+except ImportError:
+ HAVE_VECTORIO = False
+
+__version__ = "0.0.0+auto.0"
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_Display_Shapes.git"
+
+
+class FilledPolygon(displayio.Group):
+ # pylint: disable=too-few-public-methods, invalid-name
+ """A filled polygon. Technically, an arc is a Group with one or two polygons.
+
+ :param list points: A list of (x, y) tuples of the points
+ :param int|None outline: The outline of the arc. Can be a hex value for a color or
+ ``None`` for no outline.
+ :param int|None fill: The fill-color of the arc. Can be a hex value for a color or
+ ``None`` for no filling. Ignored if port does not support vectorio.
+ :param bool close: (Optional) Wether to connect first and last point. (True)
+ :param int stroke: Thickness of the outline.
+
+ """
+
+ def __init__(
+ self,
+ points: List[Tuple[int, int]],
+ *,
+ outline: Optional[int] = None,
+ fill: Optional[int] = None,
+ close: Optional[bool] = True,
+ stroke: int = 1,
+ ) -> None:
+ super().__init__()
+ self._points = points
+ self._outline = outline
+ self._fill = fill
+ self.close = close
+ self.stroke = stroke
+
+ self.palette = None
+ self.vector_polygon = None
+ self.outline_polygon = None
+
+ self._init_polygon()
+
+ def _init_polygon(self):
+ # create polygon(s) and add to ourselves
+ if HAVE_VECTORIO and self._fill is not None:
+ if self.palette is None:
+ self.palette = displayio.Palette(1)
+ self.palette[0] = self._fill
+ if self.vector_polygon is None:
+ self.vector_polygon = vectorio.Polygon(
+ pixel_shader=self.palette, points=self.points, x=0, y=0
+ )
+ self.append(self.vector_polygon)
+ else:
+ self.vector_polygon.points = self.points
+
+ if self._outline is not None:
+ if self.outline_polygon is None:
+ self.outline_polygon = Polygon(
+ self.points,
+ outline=self._outline,
+ colors=1,
+ close=self.close,
+ stroke=self.stroke,
+ )
+ else:
+ self.remove(self.outline_polygon)
+ self.outline_polygon = Polygon(
+ self.points,
+ outline=self._outline,
+ colors=1,
+ close=self.close,
+ stroke=self.stroke,
+ )
+ self.append(self.outline_polygon)
+
+ @property
+ def points(self):
+ """The points that make up the polygon"""
+ return self._points
+
+ @points.setter
+ def points(self, points):
+ self._points = points
+ self._init_polygon()
+
+ @property
+ def outline(self):
+ """The outline color. None for no outline"""
+ return self._outline
+
+ @outline.setter
+ def outline(self, value):
+ self._outline = value
+ self._init_polygon()
+
+ @property
+ def fill(self):
+ """The fill color. None for no fill"""
+ return self._fill
+
+ @fill.setter
+ def fill(self, value):
+ self._fill = value
+ self._init_polygon()

adafruit_display_shapes/polygon.py

@@ -26,6 +26,7 @@
 except ImportError:
  pass
 
+import bitmaptools
 import displayio
 
 __version__ = "0.0.0+auto.0"
@@ -42,6 +43,7 @@ class Polygon(displayio.TileGrid):
  :param int colors: (Optional) Number of colors to use. Most polygons would use two, one for
  outline and one for fill. If you're not filling your polygon, set this to 1
  for smaller memory footprint. (2)
+ :param int stroke: Thickness of the outline.
  """
 
  _OUTLINE = 1
@@ -54,6 +56,8 @@ def __init__(
  outline: Optional[int] = None,
  close: Optional[bool] = True,
  colors: Optional[int] = 2,
+ stroke: int = 1,
+ # pylint: disable=too-many-arguments
  ) -> None:
  (x_s, y_s) = zip(*points)
 
@@ -66,13 +70,14 @@ def __init__(
 
  self._palette = displayio.Palette(colors + 1)
  self._palette.make_transparent(0)
- self._bitmap = displayio.Bitmap(width, height, colors + 1)
+ self._bitmap = displayio.Bitmap(width + stroke, height + stroke, colors + 1)
+ self._stroke = stroke
 
  shifted = [(x - x_offset, y - y_offset) for (x, y) in points]
 
  if outline is not None:
  self.outline = outline
- self.draw(self._bitmap, shifted, self._OUTLINE, close)
+ self.draw(self._bitmap, shifted, self._OUTLINE, close, stroke)
 
  super().__init__(
  self._bitmap, pixel_shader=self._palette, x=x_offset, y=y_offset
@@ -84,6 +89,7 @@ def draw(
  points: List[Tuple[int, int]],
  color_id: int,
  close: Optional[bool] = True,
+ stroke=1,
  ) -> None:
  """Draw a polygon conecting points on provided bitmap with provided color_id
 
@@ -97,7 +103,7 @@ def draw(
  points.append(points[0])
 
  for index in range(len(points) - 1):
- Polygon._line_on(bitmap, points[index], points[index + 1], color_id)
+ Polygon._line_on(bitmap, points[index], points[index + 1], color_id, stroke)
 
  # pylint: disable=too-many-arguments
  def _line(
@@ -129,23 +135,36 @@ def _line_on(
  p_0: Tuple[int, int],
  p_1: Tuple[int, int],
  color: int,
+ stroke: int = 1,
  ) -> None:
  (x_0, y_0) = p_0
  (x_1, y_1) = p_1
 
- def pt_on(x, y):
- Polygon._safe_draw(bitmap, (x, y), color)
+ def pt_on(x, y, pt_size=1):
+ if pt_size > 1:
+ x = x + pt_size // 2
+ y = y + pt_size // 2
+ bitmaptools.fill_region(
+ bitmap,
+ x - (pt_size // 2),
+ y - (pt_size // 2),
+ x + (pt_size // 2),
+ y + (pt_size // 2),
+ color,
+ )
+ else:
+ Polygon._safe_draw(bitmap, (x, y), color)
 
  if x_0 == x_1:
  if y_0 > y_1:
  y_0, y_1 = y_1, y_0
  for _h in range(y_0, y_1 + 1):
- pt_on(x_0, _h)
+ pt_on(x_0, _h, stroke)
  elif y_0 == y_1:
  if x_0 > x_1:
  x_0, x_1 = x_1, x_0
  for _w in range(x_0, x_1 + 1):
- pt_on(_w, y_0)
+ pt_on(_w, y_0, stroke)
  else:
  steep = abs(y_1 - y_0) > abs(x_1 - x_0)
  if steep:
@@ -168,9 +187,9 @@ def pt_on(x, y):
 
  for x in range(x_0, x_1 + 1):
  if steep:
- pt_on(y_0, x)
+ pt_on(y_0, x, stroke)
  else:
- pt_on(x, y_0)
+ pt_on(x, y_0, stroke)
  err -= d_y
  if err < 0:
  y_0 += ystep

docs/api.rst

@@ -22,6 +22,9 @@
 .. automodule:: adafruit_display_shapes.polygon
  :members:
 
+.. automodule:: adafruit_display_shapes.filled_polygon
+ :members:
+
 .. automodule:: adafruit_display_shapes.sparkline
  :members:
 

docs/conf.py

@@ -27,7 +27,7 @@
 # Uncomment the below if you use native CircuitPython modules such as
 # digitalio, micropython and busio. List the modules you use. Without it, the
 # autodoc module docs will fail to generate with a warning.
-autodoc_mock_imports = ["displayio"]
+autodoc_mock_imports = ["displayio", "bitmaptools"]
 
 
 intersphinx_mapping = {

docs/examples.rst

@@ -60,3 +60,12 @@ Example demonstrating various arcs.
 .. literalinclude:: ../examples/display_shapes_arc.py
  :caption: examples/display_shapes_arc.py
  :linenos:
+
+Filled Polygon Simple Test
+--------------------------
+
+Example demonstrating a filled polygon
+
+.. literalinclude:: ../examples/display_shapes_filled_polygon_simpletest.py
+ :caption: examples/display_shapes_filled_polygon_simpletest.py
+ :linenos:

examples/display_shapes_filled_polygon_simpletest.py

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: 2024 Tim Cocks for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+import board
+import displayio
+from adafruit_display_shapes.filled_polygon import FilledPolygon
+
+# Make the display context
+splash = displayio.Group()
+board.DISPLAY.root_group = splash
+
+# Make a background color fill
+color_bitmap = displayio.Bitmap(320, 240, 1)
+color_palette = displayio.Palette(1)
+color_palette[0] = 0xFFFFFF
+bg_sprite = displayio.TileGrid(color_bitmap, x=0, y=0, pixel_shader=color_palette)
+splash.append(bg_sprite)
+##########################################################################
+
+# Draw a star with blue outline and pink fill
+polygon = FilledPolygon(
+ [
+ (55, 40),
+ (62, 62),
+ (85, 62),
+ (65, 76),
+ (75, 100),
+ (55, 84),
+ (35, 100),
+ (45, 76),
+ (25, 62),
+ (48, 62),
+ ],
+ outline=0x0000FF,
+ stroke=4,
+ fill=0xFF00FF,
+)
+splash.append(polygon)
+
+while True:
+ pass