sympy-plot-backends 2.0.2__tar.gz → 2.2.0__tar.gz

{sympy_plot_backends-2.0.2 → sympy_plot_backends-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sympy_plot_backends
-Version: 2.0.2
+Version: 2.2.0
 Summary: Backends for plotting with SymPy
 Home-page: https://github.com/Davide-sd/sympy-plot-backends
 Author: Davide Sandona

{sympy_plot_backends-2.0.2 → sympy_plot_backends-2.2.0}/setup.py

@@ -62,7 +62,7 @@ setup(
         "appdirs>=1.4.4",
         "numpy>=1.21.1",
         "sympy>=1.10.1",
-        "matplotlib>3.4.2",    # v3.4.2 is required for tests to pass
+        "matplotlib>3.4.2",
         "mergedeep>=1.3.4",
     ],
     extras_require={

{sympy_plot_backends-2.0.2 → sympy_plot_backends-2.2.0}/spb/__init__.py

@@ -20,14 +20,11 @@ from spb.functions import (
 from spb.vectors import plot_vector
 from spb.ccomplex.complex import (
     plot_complex, plot_complex_list,
-    plot_real_imag, plot_complex_vector
+    plot_real_imag, plot_complex_vector, plot_riemann_sphere
 )
 from spb.utils import prange
 
-from spb.plotgrid import plotgrid
-# NOTE: it would be nice to have `iplot` readily available, however loading
-# `panel` is a slow operation.
-# from spb.interactive import iplot
+from spb.plotgrid import plotgrid, PlotGrid
 
 from spb.backends.matplotlib import MB
 from spb.backends.bokeh import BB
@@ -42,5 +39,6 @@ __all__ = [
     "plot3d_revolution", "plot_implicit", "plot_polar", "plot_geometry",
     "plot_list", "plot_piecewise", "plot_vector", "plot_complex",
     "plot_complex_list", "plot_real_imag", "plot_complex_vector", "plotgrid",
-    "MB", "BB", "PB", "KB", "MAB", "plot3d_list", "prange"
+    "MB", "BB", "PB", "KB", "MAB", "plot3d_list", "prange",
+    "plot_riemann_sphere", "PlotGrid"
 ]

sympy_plot_backends-2.2.0/spb/_version.py

@@ -0,0 +1 @@
+__version__ = "2.2.0"

{sympy_plot_backends-2.0.2 → sympy_plot_backends-2.2.0}/spb/backends/base_backend.py

@@ -177,9 +177,9 @@ class Plot:
     ranges over [-pi, pi]).
     """
 
-    _allowed_keys = ["aspect", "axis", "axis_center", "backend",
+    _allowed_keys = ["aspect", "axis", "axis_center", "backend", "aouc",
     "detect_poles", "grid", "legend", "show", "size", "title", "use_latex",
-    "xlabel", "ylabel", "zlabel", "xlim", "ylim", "zlim",
+    "xlabel", "ylabel", "zlabel", "xlim", "ylim", "zlim", "show_axis",
     "xscale", "yscale", "zscale", "process_piecewise", "polar_axis", "imodule"]
     """contains a list of public keyword arguments supported by the series.
     It will be used to validate the user-provided keyword arguments.
@@ -249,6 +249,8 @@ class Plot:
         # backend might need to create different types of figure depending on
         # the interactive module being used
         self.imodule = kwargs.get("imodule", None)
+        # add annotations on unit circle in the complex plane.
+        self.aouc = kwargs.get("aouc", None)
 
         # Contains the data objects to be plotted. The backend should be smart
         # enough to iterate over this list.
@@ -269,18 +271,15 @@ class Plot:
         # Automatic legend: if more than 1 data series has been provided
         # and the user has not set legend=False, then show the legend for
         # better clarity.
-        self.legend = _legend = kwargs.get("legend", None)
-        if not self.legend:
-            self.legend = False
-            if (len([s for s in self._series if s.show_in_legend]) > 1) or (
-                any(s.is_parametric and s.use_cm for s in self._series)):
+        self.legend = kwargs.get("legend", None)
+        if self.legend is None:
+            # if len([s for s in self._series if s.show_in_legend]) > 1:
+            if len([s for s in self._series
+                if s.show_in_legend and (not s.use_cm)]) > 1:
                 # don't show the legend if `plot_piecewise` created this
                 # backend
-                if ((not ("process_piecewise" in kwargs.keys())) and
-                    ((_legend is True) or (_legend is None))):
+                if not ("process_piecewise" in kwargs.keys()):
                     self.legend = True
-            if self.legend and (len([s for s in self._series if s.is_3Dsurface and not s.use_cm]) > 1):
-                self.legend = False
 
         # Objects used to render/display the plots, which depends on the
         # plotting library.
@@ -308,6 +307,7 @@ class Plot:
         check_and_set("zlim", kwargs.get("zlim", None))
         self.size = None
         check_and_set("size", kwargs.get("size", None))
+        self.show_axis = kwargs.get("show_axis", True)
 
     def _copy_kwargs(self):
         """Copy the values of the plot attributes into a dictionary which will
@@ -333,7 +333,9 @@ class Plot:
             is_iplot=self.is_iplot,
             use_latex=self._use_latex,
             camera=self.camera,
-            polar_axis=self.polar_axis
+            polar_axis=self.polar_axis,
+            aouc=self.aouc,
+            show_axis=self.show_axis,
         )
 
     def _init_cyclers(self):
@@ -476,12 +478,6 @@ class Plot:
         series.extend(self.series)
         series.extend(other.series)
         kwargs = self._do_sum_kwargs(self, other)
-        # If the first plot (`p1`) of the summation has been created without
-        # specifying `legend`, then `p1.legend` might be False, hence
-        # `kwargs["legend"]` might be False. But when adding multiple plots
-        # it is very likely that user expect a legend to be shown. Hence,
-        # reset legend and let the backend decide if it needs one or not.
-        kwargs["legend"] = None
         return type(self)(*series, **kwargs)
 
     def append(self, arg):

{sympy_plot_backends-2.0.2 → sympy_plot_backends-2.2.0}/spb/backends/bokeh.py

@@ -1,6 +1,7 @@
 import os
 from spb.defaults import cfg
 from spb.backends.base_backend import Plot
+from spb.series import GenericDataSeries, List2DSeries
 from sympy.external import import_module
 import warnings
 
@@ -214,6 +215,10 @@ class BokehBackend(Plot):
         * Default options for streamline plots:
           ``dict(line_width=2, line_alpha=0.8)``
 
+    show_axis : boolean, optional
+        Turns on/off the axis visibility (and associated tick labels).
+        Default to True (axis are visible).
+
     theme : str, optional
         Set the theme. Find more Bokeh themes at [#fn2]_ .
 
@@ -349,6 +354,7 @@ class BokehBackend(Plot):
         if self.ylim:
             kw["y_range"] = self.ylim
         self._fig = self.bokeh.plotting.figure(**kw)
+        self._fig.axis.visible = self.show_axis
         self.grid = kwargs.get("grid", cfg["bokeh"]["grid"])
         self._fig.grid.visible = self.grid
         if cfg["bokeh"]["show_minor_grid"]:
@@ -356,6 +362,33 @@ class BokehBackend(Plot):
             self._fig.grid.minor_grid_line_color = self._fig.grid.grid_line_color[0]
             self._fig.grid.minor_grid_line_dash = cfg["bokeh"]["minor_grid_line_dash"]
 
+        if self.aouc:
+            pixel_offset = 15
+            # assumption: there is only one data series being plotted.
+            sign = 1
+            labels = ["0", "i", "-i", "1"]
+            if self.series[0].at_infinity:
+                labels[0] = "inf"
+                sign = -1
+            source = self.bokeh.models.ColumnDataSource(data={
+                "x": [0, 0, 0, 1], "y": [0, 1, -1, 0], "labels": labels,
+                "x_offset": [pixel_offset, 0, 0, sign * pixel_offset],
+                "y_offset": [0, pixel_offset, -pixel_offset, 0]
+            })
+            new_series = [
+                List2DSeries([1, 0, 0], [0, 1, -1], is_point=True,
+                    is_filled=False, show_in_legend=False,
+                    rendering_kw={"color": "#000000", "marker": "circle", "size": 6}),
+                List2DSeries([0], [0], is_point=True,
+                    is_filled=(not self.series[0].at_infinity), show_in_legend=False,
+                    rendering_kw={"color": "#000000", "marker": "circle", "size": 6}),
+                GenericDataSeries("annotations", x="x", y="y", text="labels",
+                    x_offset="x_offset", y_offset="y_offset", source=source,
+                    text_baseline="middle", text_align="center",
+                    text_font_style="bold", text_color="#000000"),
+            ]
+            self._series = self._series + new_series
+
     @property
     def fig(self):
         """Returns the figure."""
@@ -408,7 +441,7 @@ class BokehBackend(Plot):
                         x, y, param, colormap, s.get_label(self._use_latex),
                         s.rendering_kw, s.is_point)
                     self._fig.add_glyph(ds, line)
-                    if self.legend:
+                    if s.colorbar:
                         self._handles[i] = cb
                         self._fig.add_layout(cb, "right")
                 else:
@@ -422,10 +455,12 @@ class BokehBackend(Plot):
                             "ys": y if not s.is_polar else y * np.sin(x)
                         }
 
-                    color = next(self._cl) if s.line_color is None else s.line_color
-                    lkw = dict(line_width=2,
-                        legend_label=s.get_label(self._use_latex),
-                        color=color)
+                    if s.get_label(False) != "__k__":
+                        color = next(self._cl) if s.line_color is None else s.line_color
+                    else:
+                        color = "#000000"
+                    lkw = dict(line_width=2, color=color,
+                        legend_label=s.get_label(self._use_latex))
                     if not s.is_point:
                         kw = merge({}, lkw, s.rendering_kw)
                         self._fig.line("xs", "ys", source=source, **kw)
@@ -461,13 +496,14 @@ class BokehBackend(Plot):
                     **kw
                 )
 
-                colormapper = self.bokeh.models.LinearColorMapper(
-                    palette=cm, low=minz, high=maxz)
-                cbkw = dict(width=8, title=s.get_label(self._use_latex))
-                colorbar = self.bokeh.models.ColorBar(
-                    color_mapper=colormapper, **cbkw)
-                self._fig.add_layout(colorbar, "right")
-                self._handles[i] = colorbar
+                if s.colorbar:
+                    colormapper = self.bokeh.models.LinearColorMapper(
+                        palette=cm, low=minz, high=maxz)
+                    cbkw = dict(width=8, title=s.get_label(self._use_latex))
+                    colorbar = self.bokeh.models.ColorBar(
+                        color_mapper=colormapper, **cbkw)
+                    self._fig.add_layout(colorbar, "right")
+                    self._handles[i] = colorbar
 
             elif s.is_2Dvector:
                 if s.is_streamlines:
@@ -509,7 +545,7 @@ class BokehBackend(Plot):
                     glyph = self.bokeh.models.Segment(
                         x0="x0", y0="y0", x1="x1", y1="y1", **kw)
                     self._fig.add_glyph(source, glyph)
-                    if isinstance(line_color, dict):
+                    if isinstance(line_color, dict) and s.colorbar:
                         colorbar = self.bokeh.models.ColorBar(
                             color_mapper=color_mapper, width=8, title=s.get_label(self._use_latex))
                         self._fig.add_layout(colorbar, "right")
@@ -519,6 +555,10 @@ class BokehBackend(Plot):
                 x, y, mag, angle, img, colors = s.get_data()
                 img = self._get_img(img)
 
+                self._fig.x_range.flipped = s.at_infinity
+                if s.at_infinity:
+                    mag, angle, img = [np.flip(np.flip(t, axis=0),
+                        axis=1) for t in [mag, angle, img]]
                 source = self.bokeh.models.ColumnDataSource(
                     {
                         "image": [img],
@@ -535,7 +575,7 @@ class BokehBackend(Plot):
                     dh=y.max() - y.min(),
                 )
 
-                if colors is not None:
+                if (colors is not None) and s.colorbar:
                     # chroma/phase-colorbar
                     cm1 = self.bokeh.models.LinearColorMapper(
                         palette=[tuple(c) for c in colors],
@@ -544,7 +584,7 @@ class BokehBackend(Plot):
                     labels = ["-π", "-π / 2", "0", "π / 2", "π"]
                     colorbar1 = self.bokeh.models.ColorBar(
                         color_mapper=cm1,
-                        title="Argument",
+                        title="Argument" if s.get_label(False) == str(s.expr) else s.get_label(self._use_latex),
                         ticker=self.bokeh.models.tickers.FixedTicker(ticks=ticks),
                         major_label_overrides={k: v for k, v in zip(ticks, labels)})
                     self._fig.add_layout(colorbar1, "right")
@@ -578,10 +618,21 @@ class BokehBackend(Plot):
                 )
 
         if len(self._fig.legend) > 0:
-            self._fig.legend.visible = self.legend
-            # interactive legend
-            self._fig.legend.click_policy = "hide"
-            self._fig.add_layout(self._fig.legend[0], "right")
+            # hide default legend
+            self._fig.legend.visible = False
+            # add a new legend only showing the appropriate items
+            legend_items = []
+            for s, r in zip(self.series, self._fig.renderers):
+                if (s.show_in_legend and (s.is_2Dline or s.is_geometry) and
+                    (not s.use_cm)):
+                    legend_items.append(
+                        self.bokeh.models.LegendItem(
+                            label=s.get_label(self._use_latex), renderers=[r]))
+            if self.legend and (len(legend_items) > 0):
+                legend = self.bokeh.models.Legend(items=legend_items)
+                # interactive legend
+                legend.click_policy = "hide"
+                self._fig.add_layout(legend, "right")
 
     def _get_img(self, img):
         np = import_module('numpy')
@@ -675,13 +726,14 @@ class BokehBackend(Plot):
                     x, y, z = s.get_data()
                     minx, miny, minz = x.min(), y.min(), z.min()
                     maxx, maxy, maxz = x.max(), y.max(), z.max()
-                    cb = self._handles[i]
                     rend[i].data_source.data.update({"image": [z]})
                     rend[i].glyph.x = minx
                     rend[i].glyph.y = miny
                     rend[i].glyph.dw = abs(maxx - minx)
                     rend[i].glyph.dh = abs(maxy - miny)
-                    cb.color_mapper.update(low=minz, high=maxz)
+                    if s.colorbar:
+                        cb = self._handles[i]
+                        cb.color_mapper.update(low=minz, high=maxz)
 
                 elif s.is_2Dvector:
                     x, y, u, v = s.get_data()
@@ -723,9 +775,10 @@ class BokehBackend(Plot):
                                 },
                             )
                             rend[i].glyph.line_color = line_color
-                            cb = self._handles[i]
-                            cb.color_mapper.update(
-                                low=min(color_val), high=max(color_val))
+                            if s.colorbar:
+                                cb = self._handles[i]
+                                cb.color_mapper.update(
+                                    low=min(color_val), high=max(color_val))
 
                 elif s.is_complex and s.is_domain_coloring and not s.is_3Dsurface:
                     x, y, mag, angle, img, _ = s.get_data()

{sympy_plot_backends-2.0.2 → sympy_plot_backends-2.2.0}/spb/backends/k3d.py

@@ -38,9 +38,10 @@ class K3DBackend(Plot):
           - ``scale``: a float number acting as a scale multiplier.
           - ``pivot``: indicates the part of the arrow that is anchored to the
             X, Y, Z grid. It can be ``"tail", "mid", "middle", "tip"``.
-          - ``color``: set a solid color by specifying an integer color. If this
-            key is not provided, a default color or colormap is used, depenging
-            on the value of ``use_cm``.
+          - ``color``: set a solid color by specifying an integer color, or
+            a colormap by specifying one of k3d's colormaps.
+            If this key is not provided, a default color or colormap is used,
+            depending on the value of ``use_cm``.
 
           Set ``use_cm=False`` to switch to a default solid color.
 
@@ -297,13 +298,13 @@ class K3DBackend(Plot):
                         indices = Triangulation(x, y).triangles.astype(np.uint32)
                     attribute = s.eval_color_func(vertices[:, 0], vertices[:, 1], vertices[:, 2])
 
-                # self._high_aspect_ratio(x, y, z)
                 a = dict(
                     name=s.get_label(self._use_latex, "%s") if self._show_label else None,
                     side="double",
                     flat_shading=False,
                     wireframe=False,
                     color=self._convert_to_int(next(self._cl)) if s.surface_color is None else s.surface_color,
+                    colorLegend=self.legend or s.use_cm,
                 )
                 if s.use_cm:
                     a["color_map"] = next(self._cm)
@@ -344,8 +345,8 @@ class K3DBackend(Plot):
 
                 stream_kw = s.rendering_kw.copy()
                 skw = dict(width=0.1, shader="mesh")
-                if s.use_cm and ("color" not in stream_kw.keys()):
-                    skw["color_map"] = next(self._cm)
+                if s.use_cm:
+                    skw["color_map"] = stream_kw.get("color", next(self._cm))
                     skw["color_range"] = [float(np.nanmin(color_val)), float(np.nanmax(color_val))]
                     skw["attribute"] = color_val
                 else:
@@ -363,8 +364,8 @@ class K3DBackend(Plot):
                 qkw = dict(scale=1)
                 qkw = merge(qkw, s.rendering_kw)
                 quiver_kw = s.rendering_kw
-                if s.use_cm and ("color" not in quiver_kw.keys()):
-                    colormap = next(self._cm)
+                if s.use_cm:
+                    colormap = quiver_kw.get("color", next(self._cm))
                     # store useful info for interactive vector plots
                     self._handles[ii] = [qkw, colormap]
                 else:
@@ -413,18 +414,22 @@ class K3DBackend(Plot):
                     flat_shading=False,
                     wireframe=False,
                     color=self._convert_to_int(next(self._cl)),
-                    color_range=[-np.pi, np.pi],
+                    colorLegend=self.legend or s.use_cm,
                 )
                 if s.use_cm:
                     colors = colors.reshape((-1, 3))
                     a["colors"] = [self._rgb_to_int(c) for c in colors]
 
-                    r = []
-                    loc = np.linspace(0, 1, colorscale.shape[0])
-                    colorscale = colorscale / 255
-                    for l, c in zip(loc, colorscale):
-                        r.append(l)
-                        r += list(c)
+                    if colorscale is None:
+                        # grayscale colormap
+                        r = [0, 0, 0, 0, 1, 1, 1, 1]
+                    else:
+                        r = []
+                        loc = np.linspace(0, 1, colorscale.shape[0])
+                        colorscale = colorscale / 255
+                        for l, c in zip(loc, colorscale):
+                            r.append(l)
+                            r += list(c)
 
                     a["color_map"] = r
                     a["color_range"] = [-np.pi, np.pi]