Fix shape rectangle when using rotation and the axes aspect ratio != 1

Author: ericpre

lib/matplotlib/axes/_axes.py

@@ -8094,3 +8094,10 @@ def violin(self, vpstats, positions=None, vert=True, widths=0.5,
     tricontourf = mtri.tricontourf
     tripcolor = mtri.tripcolor
     triplot = mtri.triplot
+
+    def _get_aspect_ratio(self):
+        """Convenience method to calculate aspect ratio of the axes."""
+        figure_size = self.get_figure().get_size_inches()
+        ll, ur = self.get_position() * figure_size
+        width, height = ur - ll
+        return height / (width * self.get_data_ratio())

lib/matplotlib/patches.py

@@ -737,6 +737,8 @@ def __init__(self, xy, width, height, angle=0.0,
         self._height = height
         self.angle = float(angle)
         self.rotate_around_center = rotate_around_center
+        # Required for RectangleSelector with axes aspect ratio != 1
+        self._aspect_ratio_correction = 1.0
         self._convert_units()  # Validate the inputs.
 
     def get_path(self):
@@ -762,9 +764,13 @@ def get_patch_transform(self):
             rotation_point = bbox.x0 + width / 2., bbox.y0 + height / 2.
         else:
             rotation_point = bbox.x0, bbox.y0
-        return (transforms.BboxTransformTo(bbox)
-                + transforms.Affine2D().rotate_deg_around(
-                    *rotation_point, self.angle))
+        return transforms.BboxTransformTo(bbox) \
+                + transforms.Affine2D() \
+                .translate(-rotation_point[0], -rotation_point[1]) \
+                .scale(1, self._aspect_ratio_correction) \
+                .rotate_deg(self.angle) \
+                .scale(1, 1 / self._aspect_ratio_correction) \
+                .translate(*rotation_point)
 
     def get_x(self):
         """Return the left coordinate of the rectangle."""
@@ -1523,6 +1529,8 @@ def __init__(self, xy, width, height, angle=0, **kwargs):
         self._width, self._height = width, height
         self._angle = angle
         self._path = Path.unit_circle()
+        # Required for EllipseSelector with axes aspect ratio != 1
+        self._aspect_ratio_correction = 1.0
         # Note: This cannot be calculated until this is added to an Axes
         self._patch_transform = transforms.IdentityTransform()
 
@@ -1540,8 +1548,9 @@ def _recompute_transform(self):
         width = self.convert_xunits(self._width)
         height = self.convert_yunits(self._height)
         self._patch_transform = transforms.Affine2D() \
-            .scale(width * 0.5, height * 0.5) \
+            .scale(width * 0.5, height * 0.5 * self._aspect_ratio_correction) \
             .rotate_deg(self.angle) \
+            .scale(1, 1 / self._aspect_ratio_correction) \
             .translate(*center)
 
     def get_path(self):

lib/matplotlib/tests/test_widgets.py

@@ -350,61 +350,61 @@ def onselect(epress, erelease):
     _resize_rectangle(tool, 70, 65, 120, 115)
     tool.add_default_state('square')
     tool.add_default_state('center')
-    assert tool.extents == (70.0, 120.0, 65.0, 115.0)
+    assert_allclose(tool.extents, (70.0, 120.0, 65.0, 115.0))
 
     # resize NE handle
     extents = tool.extents
     xdata, ydata = extents[1], extents[3]
     xdiff, ydiff = 10, 5
     xdata_new, ydata_new = xdata + xdiff, ydata + ydiff
     _resize_rectangle(tool, xdata, ydata, xdata_new, ydata_new)
-    assert tool.extents == (extents[0] - xdiff, xdata_new,
-                            extents[2] - xdiff, extents[3] + xdiff)
+    assert_allclose(tool.extents, (extents[0] - xdiff, xdata_new,
+                                   extents[2] - xdiff, extents[3] + xdiff))
 
     # resize E handle
     extents = tool.extents
     xdata, ydata = extents[1], extents[2] + (extents[3] - extents[2]) / 2
     xdiff = 10
     xdata_new, ydata_new = xdata + xdiff, ydata
     _resize_rectangle(tool, xdata, ydata, xdata_new, ydata_new)
-    assert tool.extents == (extents[0] - xdiff, xdata_new,
-                            extents[2] - xdiff, extents[3] + xdiff)
+    assert_allclose(tool.extents, (extents[0] - xdiff, xdata_new,
+                                   extents[2] - xdiff, extents[3] + xdiff))
 
     # resize E handle negative diff
     extents = tool.extents
     xdata, ydata = extents[1], extents[2] + (extents[3] - extents[2]) / 2
     xdiff = -20
     xdata_new, ydata_new = xdata + xdiff, ydata
     _resize_rectangle(tool, xdata, ydata, xdata_new, ydata_new)
-    assert tool.extents == (extents[0] - xdiff, xdata_new,
-                            extents[2] - xdiff, extents[3] + xdiff)
+    assert_allclose(tool.extents, (extents[0] - xdiff, xdata_new,
+                                   extents[2] - xdiff, extents[3] + xdiff))
 
     # resize W handle
     extents = tool.extents
     xdata, ydata = extents[0], extents[2] + (extents[3] - extents[2]) / 2
     xdiff = 5
     xdata_new, ydata_new = xdata + xdiff, ydata
     _resize_rectangle(tool, xdata, ydata, xdata_new, ydata_new)
-    assert tool.extents == (xdata_new, extents[1] - xdiff,
-                            extents[2] + xdiff, extents[3] - xdiff)
+    assert_allclose(tool.extents, (xdata_new, extents[1] - xdiff,
+                                   extents[2] + xdiff, extents[3] - xdiff))
 
     # resize W handle negative diff
     extents = tool.extents
     xdata, ydata = extents[0], extents[2] + (extents[3] - extents[2]) / 2
     xdiff = -25
     xdata_new, ydata_new = xdata + xdiff, ydata
     _resize_rectangle(tool, xdata, ydata, xdata_new, ydata_new)
-    assert tool.extents == (xdata_new, extents[1] - xdiff,
-                            extents[2] + xdiff, extents[3] - xdiff)
+    assert_allclose(tool.extents, (xdata_new, extents[1] - xdiff,
+                                   extents[2] + xdiff, extents[3] - xdiff))
 
     # resize SW handle
     extents = tool.extents
     xdata, ydata = extents[0], extents[2]
     xdiff, ydiff = 20, 25
     xdata_new, ydata_new = xdata + xdiff, ydata + ydiff
     _resize_rectangle(tool, xdata, ydata, xdata_new, ydata_new)
-    assert tool.extents == (extents[0] + ydiff, extents[1] - ydiff,
-                            ydata_new, extents[3] - ydiff)
+    assert_allclose(tool.extents, (extents[0] + ydiff, extents[1] - ydiff,
+                                   ydata_new, extents[3] - ydiff))
 
 
 @pytest.mark.parametrize('selector_class',
@@ -421,26 +421,35 @@ def onselect(epress, erelease):
     do_event(tool, 'onmove', xdata=130, ydata=140)
     do_event(tool, 'release', xdata=130, ydata=140)
     assert tool.extents == (100, 130, 100, 140)
+    assert len(tool._default_state) == 0
+    assert len(tool._state) == 0
 
     # Rotate anticlockwise using top-right corner
     do_event(tool, 'on_key_press', key='r')
+    assert tool._default_state == set(['rotate'])
+    assert len(tool._state) == 0
     do_event(tool, 'press', xdata=130, ydata=140)
-    do_event(tool, 'onmove', xdata=110, ydata=145)
-    do_event(tool, 'release', xdata=110, ydata=145)
+    do_event(tool, 'onmove', xdata=120, ydata=145)
+    do_event(tool, 'release', xdata=120, ydata=145)
     do_event(tool, 'on_key_press', key='r')
+    assert len(tool._default_state) == 0
+    assert len(tool._state) == 0
     # Extents shouldn't change (as shape of rectangle hasn't changed)
     assert tool.extents == (100, 130, 100, 140)
+    assert_allclose(tool.rotation, 25.56, atol=0.01)
+    tool.rotation = 45
+    assert tool.rotation == 45
     # Corners should move
     # The third corner is at (100, 145)
     assert_allclose(tool.corners,
-                    np.array([[119.9, 139.9, 110.1, 90.1],
-                              [95.4, 117.8, 144.5, 122.2]]), atol=0.1)
+                    np.array([[118.53, 139.75, 111.46, 90.25],
+                              [95.25, 116.46, 144.75, 123.54]]), atol=0.01)
 
     # Scale using top-right corner
     do_event(tool, 'press', xdata=110, ydata=145)
     do_event(tool, 'onmove', xdata=110, ydata=160)
     do_event(tool, 'release', xdata=110, ydata=160)
-    assert_allclose(tool.extents, (100, 141.5, 100, 150.4), atol=0.1)
+    assert_allclose(tool.extents, (100, 139.75, 100, 151.82), atol=0.01)
 
 
 def test_rectangle_resize_square_center_aspect():
@@ -462,6 +471,7 @@ def onselect(epress, erelease):
     xdata, ydata = extents[1], extents[3]
     xdiff = 10
     xdata_new, ydata_new = xdata + xdiff, ydata
+    ychange = xdiff * 1 / tool._aspect_ratio_correction
     _resize_rectangle(tool, xdata, ydata, xdata_new, ydata_new)
     assert_allclose(tool.extents, [extents[0] - xdiff, xdata_new,
                                    46.25, 133.75])

lib/matplotlib/widgets.py

@@ -1947,9 +1947,8 @@ def press(self, event):
             key = event.key or ''
             key = key.replace('ctrl', 'control')
             # move state is locked in on a button press
-            for state in ['move']:
-                if key == self._state_modifier_keys[state]:
-                    self._state.add(state)
+            if key == self._state_modifier_keys['move']:
+                self._state.add('move')
             self._press(event)
             return True
         return False
@@ -2000,14 +1999,10 @@ def on_key_press(self, event):
                 self.clear()
                 return
             for (state, modifier) in self._state_modifier_keys.items():
-                if modifier in key.split('+'):
-                    # rotate and data_coordinates are enable/disable
-                    # on key press
-                    if (state in ['rotate', 'data_coordinates'] and
-                            state in self._state):
-                        self._state.discard(state)
-                    else:
-                        self._state.add(state)
+                # 'rotate' and 'data_coordinates' are added in _default_state
+                if (modifier in key.split('+') and
+                        state not in ['rotate', 'data_coordinates']):
+                    self._state.add(state)
             self._on_key_press(event)
 
     def _on_key_press(self, event):
@@ -2017,9 +2012,9 @@ def on_key_release(self, event):
         """Key release event handler and validator."""
         if self.active:
             key = event.key or ''
+            key = key.replace('ctrl', 'control')
             for (state, modifier) in self._state_modifier_keys.items():
-                if (modifier in key.split('+') and
-                        state not in ['rotate', 'data_coordinates']):
+                if modifier in key.split('+'):
                     self._state.discard(state)
             self._on_key_release(event)
 
@@ -2858,7 +2853,8 @@ def __init__(self, ax, onselect, drawtype='box',
         self._interactive = interactive
         self.drag_from_anywhere = drag_from_anywhere
         self.ignore_event_outside = ignore_event_outside
-        self._rotation = 0
+        self._rotation = 0.0
+        self._aspect_ratio_correction = 1.0
 
         if drawtype == 'none':  # draw a line but make it invisible
             _api.warn_deprecated(
@@ -2892,6 +2888,7 @@ def __init__(self, ax, onselect, drawtype='box',
             self.ax.add_line(to_draw)
 
         self._selection_artist = to_draw
+        self._set_aspect_ratio_correction()
 
         self.minspanx = minspanx
         self.minspany = minspany
@@ -2975,6 +2972,8 @@ def _press(self, event):
             self.set_visible(True)
 
         self._extents_on_press = self.extents
+        self._rotation_on_press = self._rotation
+        self._set_aspect_ratio_correction()
 
         return False
 
@@ -3050,13 +3049,8 @@ def _onmove(self, event):
         dy = event.ydata - eventpress.ydata
         refmax = None
         if 'data_coordinates' in state:
-            aspect_ratio = 1
             refx, refy = dx, dy
         else:
-            figure_size = self.ax.get_figure().get_size_inches()
-            ll, ur = self.ax.get_position() * figure_size
-            width, height = ur - ll
-            aspect_ratio = height / width * self.ax.get_data_ratio()
             refx = event.xdata / (eventpress.xdata + 1e-6)
             refy = event.ydata / (eventpress.ydata + 1e-6)
 
@@ -3067,8 +3061,9 @@ def _onmove(self, event):
             a = np.array([eventpress.xdata, eventpress.ydata])
             b = np.array(self.center)
             c = np.array([event.xdata, event.ydata])
-            self._rotation = (np.arctan2(c[1]-b[1], c[0]-b[0]) -
-                              np.arctan2(a[1]-b[1], a[0]-b[0]))
+            angle = (np.arctan2(c[1]-b[1], c[0]-b[0]) -
+                     np.arctan2(a[1]-b[1], a[0]-b[0]))
+            self.rotation = np.rad2deg(self._rotation_on_press + angle)
 
         # resize an existing shape
         elif self._active_handle and self._active_handle != 'C':
@@ -3083,10 +3078,10 @@ def _onmove(self, event):
                         refmax = max(refx, refy, key=abs)
                     if self._active_handle in ['E', 'W'] or refmax == refx:
                         hw = event.xdata - center[0]
-                        hh = hw / aspect_ratio
+                        hh = hw / self._aspect_ratio_correction
                     else:
                         hh = event.ydata - center[1]
-                        hw = hh * aspect_ratio
+                        hw = hh * self._aspect_ratio_correction
                 else:
                     hw = size_on_press[0] / 2
                     hh = size_on_press[1] / 2
@@ -3119,10 +3114,12 @@ def _onmove(self, event):
                         refmax = max(refx, refy, key=abs)
                     if self._active_handle in ['E', 'W'] or refmax == refx:
                         sign = np.sign(event.ydata - y0)
-                        y1 = y0 + sign * abs(x1 - x0) / aspect_ratio
+                        y1 = y0 + sign * abs(x1 - x0) / \
+                            self._aspect_ratio_correction
                     else:
                         sign = np.sign(event.xdata - x0)
-                        x1 = x0 + sign * abs(y1 - y0) * aspect_ratio
+                        x1 = x0 + sign * abs(y1 - y0) * \
+                            self._aspect_ratio_correction
 
         # move existing shape
         elif self._active_handle == 'C':
@@ -3149,9 +3146,9 @@ def _onmove(self, event):
             if 'square' in state:
                 refmax = max(refx, refy, key=abs)
                 if refmax == refx:
-                    dy = dx / aspect_ratio
+                    dy = np.sign(dy) * abs(dx) / self._aspect_ratio_correction
                 else:
-                    dx = dy * aspect_ratio
+                    dx = np.sign(dx) * abs(dy) * self._aspect_ratio_correction
 
             # from center
             if 'center' in state:
@@ -3168,6 +3165,18 @@ def _onmove(self, event):
 
         self.extents = x0, x1, y0, y1
 
+    def _on_key_press(self, event):
+        key = event.key or ''
+        key = key.replace('ctrl', 'control')
+        for (state, modifier) in self._state_modifier_keys.items():
+            if modifier in key.split('+'):
+                if state in ['rotate', 'data_coordinates']:
+                    if state in self._default_state:
+                        self._default_state.discard(state)
+                    else:
+                        self._default_state.add(state)
+                    self._set_aspect_ratio_correction()
+
     @property
     def _rect_bbox(self):
         if self._drawtype == 'box':
@@ -3178,8 +3187,27 @@ def _rect_bbox(self):
             y0, y1 = min(y), max(y)
             return x0, y0, x1 - x0, y1 - y0
 
+    def _set_aspect_ratio_correction(self):
+        aspect_ratio = self.ax._get_aspect_ratio()
+        if not hasattr(self._selection_artist, '_aspect_ratio_correction'):
+            # Aspect ratio correction is not supported with deprecated
+            # drawtype='line'. Remove this block in matplotlib 3.7
+            self._aspect_ratio_correction = 1
+            return
+
+        self._selection_artist._aspect_ratio_correction = aspect_ratio
+        if 'data_coordinates' in self._state | self._default_state:
+            self._aspect_ratio_correction = 1
+        else:
+            self._aspect_ratio_correction = aspect_ratio
+
     def _get_rotation_transform(self):
-        return Affine2D().rotate_around(*self.center, self._rotation)
+        aspect_ratio = self.ax._get_aspect_ratio()
+        return Affine2D().translate(-self.center[0], -self.center[1]) \
+                .scale(1, aspect_ratio) \
+                .rotate(self._rotation) \
+                .scale(1, 1 / aspect_ratio) \
+                .translate(*self.center)
 
     @property
     def corners(self):
@@ -3234,14 +3262,17 @@ def extents(self, extents):
 
     @property
     def rotation(self):
-        """Rotation in degree."""
+        """Rotation in degree in interval [0, 45]."""
         return np.rad2deg(self._rotation)
 
     @rotation.setter
     def rotation(self, value):
-        self._rotation = np.deg2rad(value)
-        # call extents setter to draw shape and update handles positions
-        self.extents = self.extents
+        # Restrict to a limited range of rotation [0, 45] to avoid changing
+        # order of handles
+        if 0 <= value and value <= 45:
+            self._rotation = np.deg2rad(value)
+            # call extents setter to draw shape and update handles positions
+            self.extents = self.extents
 
     draw_shape = _api.deprecate_privatize_attribute('3.5')
 
@@ -3352,7 +3383,7 @@ def _draw_shape(self, extents):
             self._selection_artist.center = center
             self._selection_artist.width = 2 * a
             self._selection_artist.height = 2 * b
-            self._selection_artist.set_angle(self.rotation)
+            self._selection_artist.angle = self.rotation
         else:
             rad = np.deg2rad(np.arange(31) * 12)
             x = a * np.cos(rad) + center[0]