Better handling of clipping, fixes for polar

projection support.

Author: isaacrobinson2000

matplotview/_transform_renderer.py

@@ -1,5 +1,7 @@
 from matplotlib.backend_bases import RendererBase
-from matplotlib.transforms import Bbox, IdentityTransform, Affine2D
+from matplotlib.patches import Rectangle
+from matplotlib.transforms import Bbox, IdentityTransform, Affine2D, \
+    TransformedPatchPath
 from matplotlib.path import Path
 import matplotlib._image as _image
 import numpy as np
@@ -101,9 +103,7 @@ def _get_axes_display_box(self):
         Private method, get the bounding box of the child axes in display
         coordinates.
         """
-        return self.__bounding_axes.patch.get_bbox().transformed(
-            self.__bounding_axes.transAxes
-        )
+        return self.__bounding_axes.get_window_extent()
 
     def _get_transfer_transform(self, orig_transform):
         """
@@ -191,6 +191,8 @@ def draw_path(self, gc, path, transform, rgbFace=None):
 
         # Change the clip to the sub-axes box
         gc.set_clip_rectangle(bbox)
+        if(not isinstance(self.__bounding_axes.patch, Rectangle)):
+            gc.set_clip_path(TransformedPatchPath(self.__bounding_axes.patch))
 
         rgbFace = tuple(rgbFace) if(rgbFace is not None) else None
 
@@ -219,12 +221,14 @@ def draw_gouraud_triangle(self, gc, points, colors, transform):
             gc = self._scale_gc(gc)
 
         gc.set_clip_rectangle(bbox)
+        if(not isinstance(self.__bounding_axes.patch, Rectangle)):
+            gc.set_clip_path(TransformedPatchPath(self.__bounding_axes.patch))
 
         self.__renderer.draw_gouraud_triangle(gc, path.vertices, colors,
                                               IdentityTransform())
 
     # Images prove to be especially messy to deal with...
-    def draw_image(self, gc, x, y, im, transform=None):
+    def draw_image(self, gc, x, y, im, transform = None):
         mag = self.get_image_magnification()
         shift_data_transform = self._get_transfer_transform(
             IdentityTransform()
@@ -273,6 +277,8 @@ def draw_image(self, gc, x, y, im, transform=None):
             gc = self._scale_gc(gc)
 
         gc.set_clip_rectangle(clipped_out_box)
+        if(not isinstance(self.__bounding_axes.patch, Rectangle)):
+            gc.set_clip_path(TransformedPatchPath(self.__bounding_axes.patch))
 
         x, y = clipped_out_box.x0, clipped_out_box.y0
 

matplotview/_view_axes.py

@@ -1,5 +1,5 @@
 import itertools
-from typing import Type, List, Optional, Callable
+from typing import Type, List, Optional, Callable, Any
 from matplotlib.axes import Axes
 from matplotlib.transforms import Bbox
 import matplotlib.docstring as docstring
@@ -9,7 +9,7 @@
 
 DEFAULT_RENDER_DEPTH = 5
 
-class BoundRendererArtist:
+class _BoundRendererArtist:
     def __init__(
         self,
         artist: Artist,
@@ -20,13 +20,13 @@ def __init__(
         self._renderer = renderer
         self._clip_box = clip_box
 
-    def __getattribute__(self, item):
+    def __getattribute__(self, item: str) -> Any:
         try:
             return super().__getattribute__(item)
         except AttributeError:
             return self._artist.__getattribute__(item)
 
-    def __setattr__(self, key, value):
+    def __setattr__(self, key: str, value: Any):
         try:
             super().__setattr__(key, value)
         except AttributeError:
@@ -36,8 +36,11 @@ def draw(self, renderer: RendererBase):
         # Disable the artist defined clip box, as the artist might be visible
         # under the new renderer even if not on screen...
         clip_box_orig = self._artist.get_clip_box()
+        clip_path_orig = self._artist.get_clip_path()
+
         full_extents = self._artist.get_window_extent(self._renderer)
-        self._artist.set_clip_box(full_extents)
+        self._artist.set_clip_box(None)
+        self._artist.set_clip_path(None)
 
         # If we are working with a 3D object, swap out it's axes with
         # this zoom axes (swapping out the 3d transform) and reproject it.
@@ -49,16 +52,21 @@ def draw(self, renderer: RendererBase):
         if(Bbox.intersection(full_extents, self._clip_box) is not None):
             self._artist.draw(self._renderer)
 
-        # Re-enable the clip box...
+        # Re-enable the clip box... and clip path...
         self._artist.set_clip_box(clip_box_orig)
+        self._artist.set_clip_path(clip_path_orig)
 
-    def do_3d_projection(self):
+    def do_3d_projection(self) -> float:
+        # Get the 3D projection function...
         do_3d_projection = getattr(self._artist, "do_3d_projection")
 
+        # Intentionally replace the axes of the artist with the view axes,
+        # as the do_3d_projection pulls the 3D transform (M) from the axes.
+        # Then reproject, and restore the original axes.
         ax = self._artist.axes
-        self._artist.axes = None
+        self._artist.axes = None  # Set to None first to avoid exception...
         self._artist.axes = self._renderer.bounding_axes
-        res = do_3d_projection()
+        res = do_3d_projection()  # Returns a z-order value...
         self._artist.axes = None
         self._artist.axes = ax
 
@@ -195,9 +203,10 @@ def get_children(self) -> List[Artist]:
 
                 init_list = super().get_children()
                 init_list.extend([
-                    BoundRendererArtist(a, mock_renderer, axes_box)
+                    _BoundRendererArtist(a, mock_renderer, axes_box)
                     for a in itertools.chain(
-                        self.__view_axes._children, self.__view_axes.child_axes
+                        self.__view_axes._children,
+                        self.__view_axes.child_axes
                     ) if(self.__filter_function(a))
                 ])
 

matplotview/tests/test_inset_zoom.py

@@ -118,8 +118,9 @@ def test_3d_view(fig_test, fig_ref):
     ax1_test, ax2_test = fig_test.subplots(
         1, 2, subplot_kw=dict(projection="3d")
     )
-    ax1_test.plot_surface(X, Y, Z)
+    ax1_test.plot_surface(X, Y, Z, cmap="plasma")
     view(ax2_test, ax1_test)
+    ax2_test.view_init(elev=80)
     ax2_test.set_xlim(-10, 10)
     ax2_test.set_ylim(-10, 10)
     ax2_test.set_zlim(-2, 2)
@@ -128,8 +129,29 @@ def test_3d_view(fig_test, fig_ref):
     ax1_ref, ax2_ref = fig_ref.subplots(
         1, 2, subplot_kw=dict(projection="3d")
     )
-    ax1_ref.plot_surface(X, Y, Z)
-    ax2_ref.plot_surface(X, Y, Z)
+    ax1_ref.plot_surface(X, Y, Z, cmap="plasma")
+    ax2_ref.plot_surface(X, Y, Z, cmap="plasma")
+    ax2_ref.view_init(elev=80)
     ax2_ref.set_xlim(-10, 10)
     ax2_ref.set_ylim(-10, 10)
-    ax2_ref.set_zlim(-2, 2)
+    ax2_ref.set_zlim(-2, 2)
+
+@check_figures_equal()
+def test_polar_view(fig_test, fig_ref):
+    r = np.arange(0, 2, 0.01)
+    theta = 2 * np.pi * r
+
+    # Test Case with polar coordinate system...
+    ax_t1, ax_t2 = fig_test.subplots(1, 2, subplot_kw=dict(projection="polar"))
+    ax_t1.plot(theta, r)
+    ax_t1.set_rmax(2)
+    view(ax_t2, ax_t1)
+    ax_t2.set_linescaling(False)
+    ax_t2.set_rmax(1)
+
+    # Reference...
+    ax_r1, ax_r2 = fig_ref.subplots(1, 2, subplot_kw=dict(projection="polar"))
+    ax_r1.plot(theta, r)
+    ax_r1.set_rmax(2)
+    ax_r2.plot(theta, r)
+    ax_r2.set_rmax(1)