adding barplot update values function

Author: jposada202020

.pylintrc

@@ -370,7 +370,7 @@ max-attributes=11
 max-bool-expr=5
 
 # Maximum number of branch for function / method body
-max-branches=12
+max-branches=18
 
 # Maximum number of locals for function / method body
 max-locals=15
@@ -385,7 +385,7 @@ max-public-methods=20
 max-returns=6
 
 # Maximum number of statements in function / method body
-max-statements=60
+max-statements=80
 
 # Minimum number of public methods for a class (see R0903).
 min-public-methods=1

circuitpython_uplot/ubar.py

@@ -45,6 +45,7 @@ def __init__(
         xstart=50,
         projection=False,
         color_palette=None,
+        max_value=None,
     ) -> None:
         """
         :param Uplot plot: Plot object for the scatter to be drawn
@@ -58,18 +59,32 @@ def __init__(
         :param list color_palette: list of colors to be used for the bars. Defaults to None.
          Be aware that you need to include the same number if colors as your data.
          This functionality will only work with filled bars.
+        :param int max_value: for filled unprojected bars will setup the maxium value for the bars.
+         This allows the user to update the bars in real-time. There is an example in the examples
+         folder showing this functionality
 
         """
+        self._bars = []
+        self._plot_obj = plot
+        self._projection = projection
+        self._filled = fill
+
+        if max_value is None:
+            y_max = max(y)
+        else:
+            y_max = max_value
+
         y = [i * plot.scale for i in y]
         self._bar_space = int(bar_space / plot.scale)
         self._graphx = plot.scale * int(
             abs(plot._newxmax - plot._newxmin) / (len(x) + 4)
         )
         self._graphy = plot.scale * int(
-            abs(plot._newymax - plot._newymin) / (max(y) + 2)
+            abs(plot._newymax - plot._newymin) / (y_max + 2)
         )
-        self._new_min = int(plot.transform(0, max(y), max(y), 0, 0))
-        self._new_max = int(plot.transform(0, max(y), max(y), 0, max(y)))
+
+        self._new_min = int(plot.transform(0, y_max, y_max, 0, 0))
+        self._new_max = int(plot.transform(0, y_max, y_max, 0, y_max))
 
         if color_palette is not None:
             if projection:
@@ -86,11 +101,14 @@ def __init__(
             self._color_palette[self._color_index] = color
 
         if plot._index_colorused >= 14:
-            plot._index_colorused = 0
+            plot._index_colorused = 2
+            self._color_index = 2
+            if color_palette:
+                self._color_index = 0
 
         if fill:
             for i, _ in enumerate(x):
-                plot.append(
+                self._bars.append(
                     Rectangle(
                         pixel_shader=self._color_palette,
                         width=self._graphx,
@@ -100,6 +118,8 @@ def __init__(
                         color_index=self._color_index,
                     )
                 )
+                plot.append(self._bars[i])
+
                 if projection:
                     delta = 20
                     rx = int(delta * math.cos(-0.5))
@@ -206,6 +226,25 @@ def _draw_rectangle(
         draw_line(plot._plotbitmap, x + width, y, x + width, y - height, color)
         draw_line(plot._plotbitmap, x + width, y - height, x, y - height, color)
 
+    def update_values(self, values: list = None):
+        """
+        Update Values of the bars
+        """
+        if self._projection:
+            raise AttributeError("Library is not designed to update projected Bars")
+        if not self._filled:
+            raise AttributeError("Library is not designed to update shell Bars")
+        if values is None:
+            raise ValueError("You must provide a list of values")
+        for i, element in enumerate(self._bars):
+            height = self._graphy * values[i]
+            y = int(
+                self._plot_obj._newymin
+                - self._graphy * values[i] / self._plot_obj.scale
+            )
+            element.height = height
+            element.y = y
+
 
 def color_fader(source_color=None, brightness=1.0, gamma=1.0):
     """

circuitpython_uplot/uplot.py

@@ -131,7 +131,7 @@ def __init__(
         if show_box:
             self._drawbox()
 
-        self._plot_palette = displayio.Palette(17)
+        self._plot_palette = displayio.Palette(20)
         self._plot_palette[0] = background_color
         self._plot_palette[1] = box_color
         self._plot_palette[2] = self._tickcolor
@@ -145,7 +145,14 @@ def __init__(
         self._plot_palette[10] = 0x64A813
         self._plot_palette[11] = 0x0F4E12
         self._plot_palette[12] = 0xF0075E
-        self._plot_palette[13] = 0x1AF0FF
+        self._plot_palette[13] = 0x123456
+        self._plot_palette[14] = 0xFF00FF
+        self._plot_palette[15] = 0xFF0000
+        self._plot_palette[16] = 0x440044
+        self._plot_palette[17] = 0x2222FF
+        self._plot_palette[18] = 0x1A50FF
+        self._plot_palette[19] = 0xF0FF32
+
         self.append(
             displayio.TileGrid(
                 self._plotbitmap, pixel_shader=self._plot_palette, x=0, y=0

docs/examples.rst

@@ -93,6 +93,16 @@ Bar plot example showing how to pass a user color Palette
 .. image:: ../docs/bar_palette.jpg
 
 
+Bar plot updating values Example
+---------------------------------
+
+Bar Plot example showing how to update values for a filled bars bar plot
+
+.. literalinclude:: ../examples/uplot_ubar_updating_values.py
+    :caption: examples/uplot_ubar_updating_values.py
+    :lines: 5-
+
+
 Ubar 3D Example
 ----------------
 

docs/quick_start.rst

@@ -344,6 +344,31 @@ appearance
     ubar(plot, a, b, color=0xFF1000, fill=True, bar_space=30, xstart=70, projection=True)
 
 
+For filled unprojected bar you can update their values. This is useful for data logging.
+the max_value argument will allow you to set the maximum value of the graph. The plot will scale
+according to this max value, and bar plot will update their values accordingly
+
+.. code-block:: python
+
+    import board
+    from circuitpython_uplot.uplot import Uplot
+    from circuitpython_uplot.ubar import ubar
+
+    display = board.DISPLAY
+    plot = Uplot(0, 0, display.width, display.height)
+
+
+    a = ["a", "b", "c", "d"]
+    b = [3, 5, 1, 7]
+    my_ubar = ubar(plot, a, b, color=0xFF1000, fill=True, color_palette=[0xFF1000, 0x00FF00, 0xFFFF00, 0x123456], max_value=10)
+
+
+Then you can update the values of the bar plot:
+
+.. code-block:: python
+
+    my_ubar.update_values([1, 2, 3, 4])
+
 ===============
 Fillbetween
 ===============

examples/uplot_ubar_updating_values.py

@@ -0,0 +1,64 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 Jose D. Montoya
+#
+# SPDX-License-Identifier: MIT
+
+import board
+from circuitpython_uplot.uplot import Uplot, color
+from circuitpython_uplot.ubar import ubar
+import time
+
+# Setting up the display
+display = board.DISPLAY
+
+# Configuring display dimensions
+DISPLAY_WIDTH = 480
+DISPLAY_HEIGHT = 320
+
+# Defining the plot
+plot = Uplot(
+    0,
+    0,
+    DISPLAY_WIDTH,
+    DISPLAY_HEIGHT,
+    background_color=color.BLACK,
+    padding=10,
+    box_color=color.BLACK,
+)
+
+# Dummy data to plot
+some_values = [55, 20, 25, 30, 35, 10]
+a = ["a", "b", "c", "d", "e", "f"]
+
+add = 1
+# Showing the plot
+display.show(plot)
+
+# Creating the bar
+my_ubar = ubar(
+    plot,
+    a,
+    some_values,
+    0xFF1000,
+    True,
+    color_palette=[
+        0xFF1000,
+        0x00FF00,
+        0x0000FF,
+        0xFFFF00,
+        0x00FFFF,
+        0x123456,
+    ],
+    max_value=100,
+)
+
+for i in range(20):
+    values_changed = [j + add for j in some_values]
+    my_ubar.update_values(values_changed)
+    add += 1
+    time.sleep(0.1)
+
+for i in range(20):
+    values_changed = [j + add for j in some_values]
+    my_ubar.update_values(values_changed)
+    add -= 1
+    time.sleep(0.1)