axvline()/axvspan() should not update r limits in polar plots.

Special-casing a check for get_xaxis_transform() is a bit ugly and
definitely not general, but fixes the main issue at hand...

(Shortening the variable names to _trf mostly helps avoiding line
continuations, and I also made the layout in _update_line_limits and
_update_patch_limits closer to one another; the main relevant change
feature-wise is just the `if name != "rectilinear"` blocks.)

Author: anntzer

lib/matplotlib/axes/_base.py

@@ -2289,41 +2289,45 @@ def _update_line_limits(self, line):
         if path.vertices.size == 0:
             return
 
-        line_trans = line.get_transform()
+        line_trf = line.get_transform()
 
-        if line_trans == self.transData:
+        if line_trf == self.transData:
             data_path = path
-
-        elif any(line_trans.contains_branch_seperately(self.transData)):
-            # identify the transform to go from line's coordinates
-            # to data coordinates
-            trans_to_data = line_trans - self.transData
-
-            # if transData is affine we can use the cached non-affine component
-            # of line's path. (since the non-affine part of line_trans is
-            # entirely encapsulated in trans_to_data).
+        elif any(line_trf.contains_branch_seperately(self.transData)):
+            # Compute the transform from line coordinates to data coordinates.
+            trf_to_data = line_trf - self.transData
+            # If transData is affine we can use the cached non-affine component
+            # of line's path (since the non-affine part of line_trf is
+            # entirely encapsulated in trf_to_data).
             if self.transData.is_affine:
                 line_trans_path = line._get_transformed_path()
                 na_path, _ = line_trans_path.get_transformed_path_and_affine()
-                data_path = trans_to_data.transform_path_affine(na_path)
+                data_path = trf_to_data.transform_path_affine(na_path)
             else:
-                data_path = trans_to_data.transform_path(path)
+                data_path = trf_to_data.transform_path(path)
         else:
-            # for backwards compatibility we update the dataLim with the
+            # For backwards compatibility we update the dataLim with the
             # coordinate range of the given path, even though the coordinate
             # systems are completely different. This may occur in situations
             # such as when ax.transAxes is passed through for absolute
             # positioning.
             data_path = path
 
-        if data_path.vertices.size > 0:
-            updatex, updatey = line_trans.contains_branch_seperately(
-                self.transData)
-            self.dataLim.update_from_path(data_path,
-                                          self.ignore_existing_data_limits,
-                                          updatex=updatex,
-                                          updatey=updatey)
-            self.ignore_existing_data_limits = False
+        if not data_path.vertices.size:
+            return
+
+        updatex, updatey = line_trf.contains_branch_seperately(self.transData)
+        if self.name != "rectilinear":
+            # This block is mostly intended to handle axvline in polar plots,
+            # for which updatey would otherwise be True.
+            if updatex and line_trf == self.get_yaxis_transform():
+                updatex = False
+            if updatey and line_trf == self.get_xaxis_transform():
+                updatey = False
+        self.dataLim.update_from_path(data_path,
+                                      self.ignore_existing_data_limits,
+                                      updatex=updatex, updatey=updatey)
+        self.ignore_existing_data_limits = False
 
     def add_patch(self, p):
         """
@@ -2354,17 +2358,19 @@ def _update_patch_limits(self, patch):
         p = patch.get_path()
         vertices = p.vertices if p.codes is None else p.vertices[np.isin(
             p.codes, (mpath.Path.CLOSEPOLY, mpath.Path.STOP), invert=True)]
-        if vertices.size > 0:
-            xys = patch.get_patch_transform().transform(vertices)
-            if patch.get_data_transform() != self.transData:
-                patch_to_data = (patch.get_data_transform() -
-                                 self.transData)
-                xys = patch_to_data.transform(xys)
-
-            updatex, updatey = patch.get_transform().\
-                contains_branch_seperately(self.transData)
-            self.update_datalim(xys, updatex=updatex,
-                                updatey=updatey)
+        if not vertices.size:
+            return
+        patch_trf = patch.get_transform()
+        updatex, updatey = patch_trf.contains_branch_seperately(self.transData)
+        if self.name != "rectilinear":
+            # As in _update_line_limits, but for axvspan.
+            if updatex and patch_trf == self.get_yaxis_transform():
+                updatex = False
+            if updatey and patch_trf == self.get_xaxis_transform():
+                updatey = False
+        trf_to_data = patch_trf - self.transData
+        xys = trf_to_data.transform(vertices)
+        self.update_datalim(xys, updatex=updatex, updatey=updatey)
 
     def add_table(self, tab):
         """

lib/matplotlib/tests/test_polar.py

@@ -402,3 +402,11 @@ def test_shared_polar_keeps_ticklabels():
     fig.canvas.draw()
     assert axs[0, 1].xaxis.majorTicks[0].get_visible()
     assert axs[0, 1].yaxis.majorTicks[0].get_visible()
+
+
+def test_axvline_axvspan_do_not_modify_rlims():
+    ax = plt.subplot(projection="polar")
+    ax.axvspan(0, 1)
+    ax.axvline(.5)
+    ax.plot([.1, .2])
+    assert ax.get_ylim() == (0, .2)