Use alpha=1 as default for batch commands

Author: martinRenou

docs/source/drawing_shapes.rst

@@ -357,7 +357,7 @@ Circles
     with hold_canvas(canvas):
         canvas.fill_styled_circles(x, y, r, color=colors_fill, alpha=alphas)
         canvas.line_width = 2
-        canvas.stroke_styled_circles(x, y, r, color=colors_outline, alpha=1)
+        canvas.stroke_styled_circles(x, y, r, color=colors_outline)
     canvas
 
 
@@ -441,7 +441,7 @@ Case 1: All polygons / line-segments have the same number of points
 
     points_per_polygon = np.ones([n_polygons]) * n_points_per_polygon
     with hold_canvas(canvas):
-        canvas.stroke_styled_polygons(polygons, color=colors_fill, alpha=1)
+        canvas.stroke_styled_polygons(polygons, color=colors_fill)
     canvas
 
 
@@ -474,7 +474,7 @@ Case 1: All polygons / line-segments have the same number of points
                                           num=n_line_segments)[:, None]
 
     with hold_canvas(canvas):
-        canvas.stroke_styled_line_segments(line_segments, color=colors_fill, alpha=1)
+        canvas.stroke_styled_line_segments(line_segments, color=colors_fill)
     canvas
 
 
@@ -501,7 +501,7 @@ Polygons can be given as a list of ndarrays:
     colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255)]
 
     with hold_canvas(canvas):
-        canvas.fill_styled_polygons(polygons, color=colors, alpha=1)
+        canvas.fill_styled_polygons(polygons, color=colors)
     canvas
 
 .. image:: images/draw_styled_polygons_from_list.png

examples/3d_monkey.ipynb

@@ -317,24 +317,28 @@
     "        self.draw()\n",
     "\n",
     "    def draw(self):\n",
-    "        with hold_canvas(self):\n",
-    "            self.clear()\n",
+    "        triangles = []\n",
+    "        colors = []\n",
+    "\n",
+    "        # Now let's draw triangles\n",
+    "        for i in self.order:\n",
+    "            triangle = np.array(self.proj_triangles[i])\n",
+    "            # print(triangle)\n",
+    "            normal = self.triangles_normals[i]\n",
     "\n",
-    "            # Now let's draw triangles\n",
-    "            for i in self.order:\n",
-    "                triangle = self.proj_triangles[i]\n",
-    "                normal = self.triangles_normals[i]\n",
+    "            # Shading depending on light direction and face normal\n",
+    "            light = np.dot(light_direction, normal)\n",
+    "            if light < 0.4:\n",
+    "                light = 0.4\n",
+    "            elif light > 1:\n",
+    "                light = 1\n",
     "\n",
-    "                # Shading depending on light direction and face normal\n",
-    "                light = np.dot(light_direction, normal)\n",
-    "                if light < 0.4:\n",
-    "                    light = 0.4\n",
-    "                elif light > 1:\n",
-    "                    light = 1\n",
-    "                r, g, b = int(214 * light), int(224 * light), int(125 * light)\n",
-    "                self.fill_style = \"rgb({}, {}, {})\".format(r, g, b)\n",
+    "            triangles.append(triangle)\n",
+    "            colors.append([int(214 * light), int(224 * light), int(125 * light)])\n",
     "\n",
-    "                self.fill_polygon(triangle)\n",
+    "        with hold_canvas(self):\n",
+    "            self.clear()\n",
+    "            self.fill_styled_polygons(triangles, colors)\n",
     "\n",
     "    def mouse_down_handler(self, pixel_x, pixel_y):\n",
     "        self.dragging = True\n",
@@ -370,11 +374,18 @@
     "monkey = Monkey()\n",
     "monkey"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -388,7 +399,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.0"
+   "version": "3.10.0"
   }
  },
  "nbformat": 4,

examples/animation.ipynb

@@ -221,7 +221,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -235,7 +235,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.0"
+   "version": "3.10.0"
   }
  },
  "nbformat": 4,

examples/batch_drawing.ipynb

@@ -148,7 +148,7 @@
     "with hold_canvas(canvas):\n",
     "    canvas.fill_styled_circles(x, y, r, color=colors_fill, alpha=alphas)\n",
     "    canvas.line_width = 2\n",
-    "    canvas.stroke_styled_circles(x, y, r, color=colors_outline, alpha=1)\n",
+    "    canvas.stroke_styled_circles(x, y, r, color=colors_outline)\n",
     "canvas"
    ]
   },
@@ -216,11 +216,9 @@
     "colors_outline = np.random.randint(0, 255, size=(n_circles, 3))\n",
     "alphas = np.random.random(n_circles)\n",
     "with hold_canvas(canvas):\n",
-    "    canvas.fill_styled_arcs(x, y, r, start_angle, end_angle, color=colors_fill, alpha=1)\n",
+    "    canvas.fill_styled_arcs(x, y, r, start_angle, end_angle, color=colors_fill)\n",
     "    canvas.line_width = 3\n",
-    "    canvas.stroke_styled_arcs(\n",
-    "        x, y, r, start_angle, end_angle, color=colors_outline, alpha=1\n",
-    "    )\n",
+    "    canvas.stroke_styled_arcs(x, y, r, start_angle, end_angle, color=colors_outline)\n",
     "canvas"
    ]
   },
@@ -273,7 +271,7 @@
     "\n",
     "points_per_polygon = np.ones([n_polygons]) * n_points_per_polygon\n",
     "with hold_canvas(canvas):\n",
-    "    canvas.stroke_styled_polygons(polygons, color=colors_fill, alpha=1)\n",
+    "    canvas.stroke_styled_polygons(polygons, color=colors_fill)\n",
     "canvas"
    ]
   },
@@ -304,7 +302,7 @@
     "line_segments[:, :, 1] += np.linspace(1.0, canvas.height, num=n_line_segments)[:, None]\n",
     "\n",
     "with hold_canvas(canvas):\n",
-    "    canvas.stroke_styled_line_segments(line_segments, color=colors_fill, alpha=1)\n",
+    "    canvas.stroke_styled_line_segments(line_segments, color=colors_fill)\n",
     "canvas"
    ]
   },
@@ -337,7 +335,7 @@
     "colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255)]\n",
     "\n",
     "with hold_canvas(canvas):\n",
-    "    canvas.fill_styled_polygons(polygons, color=colors, alpha=1)\n",
+    "    canvas.fill_styled_polygons(polygons, color=colors)\n",
     "canvas"
    ]
   },
@@ -398,7 +396,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.7"
+   "version": "3.10.0"
   }
  },
  "nbformat": 4,

ipycanvas/canvas.py

@@ -519,7 +519,7 @@ def stroke_rects(self, x, y, width, height=None):
 
         self._send_canvas_command(COMMANDS['strokeRects'], args, buffers)
 
-    def fill_styled_rects(self, x, y, width, height, color, alpha):
+    def fill_styled_rects(self, x, y, width, height, color, alpha=1):
         """Draw filled and styled rectangles of sizes ``(width, height)`` at the ``(x, y)`` positions
 
         Where ``x``, ``y``, ``width`` and ``height`` arguments are NumPy arrays, lists or scalar values.
@@ -543,7 +543,7 @@ def fill_styled_rects(self, x, y, width, height, color, alpha):
         populate_args(alpha, args, buffers)
         self._send_canvas_command(COMMANDS['fillStyledRects'], args, buffers)
 
-    def stroke_styled_rects(self, x, y, width, height, color, alpha):
+    def stroke_styled_rects(self, x, y, width, height, color, alpha=1):
         """Draw rectangular styled outlines of sizes ``(width, height)`` at the ``(x, y)`` positions.of sizes ``(width, height)``
 
         Where ``x``, ``y``, ``width`` and ``height`` arguments are NumPy arrays, lists or scalar values.
@@ -653,7 +653,7 @@ def stroke_circles(self, x, y, radius):
 
         self._send_canvas_command(COMMANDS['strokeCircles'], args, buffers)
 
-    def fill_styled_circles(self, x, y, radius, color, alpha):
+    def fill_styled_circles(self, x, y, radius, color, alpha=1):
         """Draw a filled circles centered at ``(x, y)`` with a radius of ``radius``.
 
         Where ``x``, ``y``, ``radius``  and ``alpha`  are NumPy arrays, lists or scalar values.
@@ -669,7 +669,7 @@ def fill_styled_circles(self, x, y, radius, color, alpha):
         populate_args(alpha, args, buffers)
         self._send_canvas_command(COMMANDS['fillStyledCircles'], args, buffers)
 
-    def stroke_styled_circles(self, x, y, radius, color, alpha):
+    def stroke_styled_circles(self, x, y, radius, color, alpha=1):
         """Draw filled circles centered at ``(x, y)`` with a radius of ``radius``.
 
         Where ``x``, ``y``, ``radius``  and ``alpha``  are NumPy arrays, lists or scalar values.
@@ -685,7 +685,7 @@ def stroke_styled_circles(self, x, y, radius, color, alpha):
         populate_args(alpha, args, buffers)
         self._send_canvas_command(COMMANDS['strokeStyledCircles'], args, buffers)
 
-    def fill_styled_arcs(self, x, y, radius, start_angle, end_angle, color, alpha, anticlockwise=False):
+    def fill_styled_arcs(self, x, y, radius, start_angle, end_angle, color, alpha=1, anticlockwise=False):
         """Draw filled and styled arcs centered at ``(x, y)`` with a radius of ``radius``.
 
         Where ``x``, ``y``, ``radius`` and other arguments are NumPy arrays, lists or scalar values.
@@ -704,7 +704,7 @@ def fill_styled_arcs(self, x, y, radius, start_angle, end_angle, color, alpha, a
 
         self._send_canvas_command(COMMANDS['fillStyledArcs'], args, buffers)
 
-    def stroke_styled_arcs(self, x, y, radius, start_angle, end_angle, color, alpha, anticlockwise=False):
+    def stroke_styled_arcs(self, x, y, radius, start_angle, end_angle, color, alpha=1, anticlockwise=False):
         """Draw an styled arc outlines centered at ``(x, y)`` with a radius of ``radius``.
 
         Where ``x``, ``y``, ``radius`` and other arguments are NumPy arrays, lists or scalar values.
@@ -791,7 +791,7 @@ def stroke_polygons(self, points, points_per_polygon=None):
         """
         self._draw_polygons_or_linesegments('strokePolygons', points, None, None, points_per_polygon, False, 3, "polygon")
 
-    def fill_styled_polygons(self, points, color, alpha, points_per_polygon=None):
+    def fill_styled_polygons(self, points, color, alpha=1, points_per_polygon=None):
         """" Draw many filled polygons at once:
 
             Args:
@@ -821,7 +821,7 @@ def fill_styled_polygons(self, points, color, alpha, points_per_polygon=None):
         """
         self._draw_polygons_or_linesegments('fillStyledPolygons', points, color, alpha, points_per_polygon, True, 3, "polygon")
 
-    def stroke_styled_polygons(self, points, color, alpha, points_per_polygon=None):
+    def stroke_styled_polygons(self, points, color, alpha=1, points_per_polygon=None):
         """" Draw many stroked polygons at once:
 
             Args:
@@ -865,7 +865,7 @@ def stroke_lines(self, points):
 
         self._send_canvas_command(COMMANDS['strokeLines'], args, buffers)
 
-    def stroke_styled_line_segments(self, points, color, alpha, points_per_line_segment=None):
+    def stroke_styled_line_segments(self, points, color, alpha=1, points_per_line_segment=None):
         """ Draw many line segments at once:
 
             Args: