Multiview support now fully working, new

test for it.

Author: isaacrobinson2000

matplotview/__init__.py

@@ -3,13 +3,13 @@
 from matplotlib.axes import Axes
 from matplotview._view_axes import view_wrapper, ViewSpecification, DEFAULT_RENDER_DEPTH
 
-__all__ = ["view", "inset_zoom_axes"]
+__all__ = ["view", "inset_zoom_axes", "ViewSpecification"]
 
 def view(
     axes: Axes,
     axes_to_view: Axes,
     image_interpolation: str = "nearest",
-    render_depth: int = DEFAULT_RENDER_DEPTH,
+    render_depth: Optional[int] = None,
     filter_set: Optional[Iterable[Union[Type[Artist], Artist]]] = None,
     scale_lines: bool = True
 ) -> Axes:
@@ -34,14 +34,17 @@ def view(
         'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos',
         or 'none'
 
-    render_depth: int, positive, defaults to 5
+    render_depth: optional int, positive, defaults to None
         The number of recursive draws allowed for this view, this can happen
         if the view is a child of the axes (such as an inset axes) or if
-        two views point at each other. Defaults to 5.
+        two views point at each other. If None, uses the default render depth
+        of 5, unless the axes passed is already a view axes, in which case the
+        render depth the view already has will be used.
 
     filter_set: Iterable[Union[Type[Artist], Artist]] or None
         An optional filter set, which can be used to select what artists
-        are drawn by the view. Any artists types in the set are not drawn.
+        are drawn by the view. Any artists or artist types in the set are not
+        drawn.
 
     scale_lines: bool, defaults to True
         Specifies if lines should be drawn thicker based on scaling in the
@@ -60,12 +63,12 @@ def inset_zoom_axes(
     axes: Axes,
     bounds: Iterable,
     *,
-    image_interpolation="nearest",
-    render_depth: int = DEFAULT_RENDER_DEPTH,
+    image_interpolation: str = "nearest",
+    render_depth: Optional[int] = None,
     filter_set: Optional[Iterable[Union[Type[Artist], Artist]]] = None,
     scale_lines: bool = True,
-    transform=None,
-    zorder=5,
+    transform = None,
+    zorder: int = 5,
     **kwargs
 ) -> Axes:
     """
@@ -97,10 +100,12 @@ def inset_zoom_axes(
         determines the interpolation used when attempting to render a
         zoomed version of an image.
 
-    render_depth: int, positive, defaults to 5
+    render_depth: optional int, positive, defaults to None
         The number of recursive draws allowed for this view, this can happen
         if the view is a child of the axes (such as an inset axes) or if
-        two views point at each other. Defaults to 5.
+        two views point at each other. If None, uses the default render depth
+        of 5, unless the axes passed is already a view axes, in which case the
+        render depth the view already has will be used.
 
     filter_set: Iterable[Union[Type[Artist], Artist]] or None
         An optional filter set, which can be used to select what artists

matplotview/_view_axes.py

@@ -106,6 +106,12 @@ def __post_init__(self):
             self.filter_set = set(self.filter_set)
         self.scale_lines = bool(self.scale_lines)
 
+class __ViewType:
+    """
+    PRIVATE: A simple identifier class for identifying view types, a view
+    will inherit from the axes class it is wrapping and this type...
+    """
+    ...
 
 # Cache classes so grabbing the same type twice leads to actually getting the
 # same type (and type comparisons work).
@@ -127,8 +133,11 @@ def view_wrapper(axes_class: Type[Axes]) -> Type[Axes]:
         The view axes wrapper for a given axes class, capable of displaying
         another axes contents...
     """
+    if(issubclass(axes_class, Axes) and issubclass(axes_class, __ViewType)):
+        return axes_class
+
     @docstring.interpd
-    class View(axes_class):
+    class View(axes_class, __ViewType):
         """
         An axes which automatically displays elements of another axes. Does not
         require Artists to be plotted twice.
@@ -151,10 +160,10 @@ def __init__(
                 Additional arguments to be passed to the Axes class this
                 ViewAxes wraps.
 
-            render_depth: int, positive, defaults to 10
+            render_depth: int, positive, defaults to 5
                 The number of recursive draws allowed for this view, this can
                 happen if the view is a child of the axes (such as an inset
-                axes) or if two views point at each other. Defaults to 10.
+                axes) or if two views point at each other. Defaults to 5.
 
             **kwargs
                 Other optional keyword arguments supported by the Axes
@@ -171,10 +180,12 @@ def __init__(
             self._init_vars(render_depth)
 
         def _init_vars(self, render_depth: int = DEFAULT_RENDER_DEPTH):
-            # Initialize the view specs set...
-            self.__view_specs = {}
+            # Initialize the view specs dict...
+            self.__view_specs = getattr(self, "__view_specs", {})
             self.__renderer = None
-            self.__max_render_depth = DEFAULT_RENDER_DEPTH
+            self.__max_render_depth = getattr(
+                self, "__max_render_depth", DEFAULT_RENDER_DEPTH
+            )
             self.set_max_render_depth(render_depth)
             # The current render depth is stored in the figure, so the number
             # of recursive draws is even in the case of multiple axes drawing
@@ -297,11 +308,14 @@ def view_specifications(self) -> Dict[Axes, ViewSpecification]:
             """
             return self.__view_specs
 
+        # Shortcut for easier access...
+        view_specs = view_specifications
+
         @classmethod
         def from_axes(
             cls,
             axes: Axes,
-            render_depth: int = DEFAULT_RENDER_DEPTH
+            render_depth: Optional[int] = None
         ) -> Axes:
             """
             Convert an Axes into a View in-place. This is used by public
@@ -314,10 +328,11 @@ def from_axes(
             axes: Axes
                 The axes to convert to a view wrapping the same axes type.
 
-            render_depth: int, positive, defaults to 10
+            render_depth: optional int, positive, defaults to None
                 The number of recursive draws allowed for this view, this can
                 happen if the view is a child of the axes (such as an inset
-                axes) or if two views point at each other. Defaults to 10.
+                axes) or if two views point at each other. If none, use the
+                default value (5) if the render depth is not already set.
 
             Returns
             -------
@@ -329,18 +344,24 @@ def from_axes(
             ------
             TypeError
                 If the provided axes to convert has an Axes type which does
-                not match the axes class this view type wraps.ss
+                not match the axes class this view type wraps.
             """
+            if(isinstance(axes, cls)):
+                if(render_depth is not None):
+                    axes.set_max_render_depth(render_depth)
+                return axes
+
             if(type(axes) != axes_class):
                 raise TypeError(
                     f"Can't convert {type(axes).__name__} to {cls.__name__}"
                 )
 
-            if(isinstance(axes, cls)):
-                return axes
-
             axes.__class__ = cls
-            axes._init_vars(render_depth)
+            axes._init_vars(
+                DEFAULT_RENDER_DEPTH
+                if(render_depth is None)
+                else render_depth
+            )
             return axes
 
     View.__name__ = f"{View.__name__}[{axes_class.__name__}]"

matplotview/tests/test_view_rendering.py

@@ -181,3 +181,38 @@ def test_map_projection_view(fig_test, fig_ref):
     ax_r1.add_patch(circ_gen())
     ax_r2.plot(x, y)
     ax_r2.add_patch(circ_gen())
+
+
+@check_figures_equal()
+def test_double_view(fig_test, fig_ref):
+    # Test case...
+    ax_test1, ax_test2, ax_test3 = fig_test.subplots(1, 3)
+
+    ax_test1.add_patch(plt.Circle((1, 1), 1.5, ec="black", fc=(0, 0, 1, 0.5)))
+    ax_test3.add_patch(plt.Circle((3, 1), 1.5, ec="black", fc=(1, 0, 0, 0.5)))
+
+    ax_test2 = view(
+        view(ax_test2, ax_test1, scale_lines=False),
+        ax_test3, scale_lines=False
+    )
+
+    ax_test2.set_aspect(1)
+    ax_test2.set_xlim(-0.5, 4.5)
+    ax_test2.set_ylim(-0.5, 2.5)
+
+    # Reference...
+    ax_ref1, ax_ref2, ax_ref3 = fig_ref.subplots(1, 3)
+
+    ax_ref1.add_patch(plt.Circle((1, 1), 1.5, ec="black", fc=(0, 0, 1, 0.5)))
+    ax_ref3.add_patch(plt.Circle((3, 1), 1.5, ec="black", fc=(1, 0, 0, 0.5)))
+
+    ax_ref2.add_patch(plt.Circle((1, 1), 1.5, ec="black", fc=(0, 0, 1, 0.5)))
+    ax_ref2.add_patch(plt.Circle((3, 1), 1.5, ec="black", fc=(1, 0, 0, 0.5)))
+    ax_ref2.set_aspect(1)
+    ax_ref2.set_xlim(-0.5, 4.5)
+    ax_ref2.set_ylim(-0.5, 2.5)
+
+    for ax in (ax_test1, ax_test3, ax_ref1, ax_ref3):
+        ax.set_aspect(1)
+        ax.relim()
+        ax.autoscale_view()