Merge pull request #7873 from QuLogic/LockedBbox

efiring · web-flow · commit 4e8c7fe64138 · 2017-07-27T14:46:33.000-10:00
ENH: Add a LockableBbox type.
diff --git a/lib/matplotlib/tests/test_transforms.py b/lib/matplotlib/tests/test_transforms.py
@@ -600,3 +600,37 @@ def test_transformed_patch_path():
     # from the transform).
     patch.set_radius(0.5)
     assert_allclose(tpatch.get_fully_transformed_path().vertices, points)
+
+
+@pytest.mark.parametrize('locked_element', ['x0', 'y0', 'x1', 'y1'])
+def test_lockable_bbox(locked_element):
+    other_elements = ['x0', 'y0', 'x1', 'y1']
+    other_elements.remove(locked_element)
+
+    orig = mtransforms.Bbox.unit()
+    locked = mtransforms.LockableBbox(orig, **{locked_element: 2})
+
+    # LockableBbox should keep its locked element as specified in __init__.
+    assert getattr(locked, locked_element) == 2
+    assert getattr(locked, 'locked_' + locked_element) == 2
+    for elem in other_elements:
+        assert getattr(locked, elem) == getattr(orig, elem)
+
+    # Changing underlying Bbox should update everything but locked element.
+    orig.set_points(orig.get_points() + 10)
+    assert getattr(locked, locked_element) == 2
+    assert getattr(locked, 'locked_' + locked_element) == 2
+    for elem in other_elements:
+        assert getattr(locked, elem) == getattr(orig, elem)
+
+    # Unlocking element should revert values back to the underlying Bbox.
+    setattr(locked, 'locked_' + locked_element, None)
+    assert getattr(locked, 'locked_' + locked_element) is None
+    assert np.all(orig.get_points() == locked.get_points())
+
+    # Relocking an element should change its value, but not others.
+    setattr(locked, 'locked_' + locked_element, 3)
+    assert getattr(locked, locked_element) == 3
+    assert getattr(locked, 'locked_' + locked_element) == 3
+    for elem in other_elements:
+        assert getattr(locked, elem) == getattr(orig, elem)
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
@@ -1095,6 +1095,131 @@ def get_points(self):
             return points
 
 
+class LockableBbox(BboxBase):
+    """
+    A :class:`Bbox` where some elements may be locked at certain values.
+
+    When the child bounding box changes, the bounds of this bbox will update
+    accordingly with the exception of the locked elements.
+    """
+    def __init__(self, bbox, x0=None, y0=None, x1=None, y1=None, **kwargs):
+        """
+        Parameters
+        ----------
+        bbox : Bbox
+            The child bounding box to wrap.
+
+        x0 : float or None
+            The locked value for x0, or None to leave unlocked.
+
+        y0 : float or None
+            The locked value for y0, or None to leave unlocked.
+
+        x1 : float or None
+            The locked value for x1, or None to leave unlocked.
+
+        y1 : float or None
+            The locked value for y1, or None to leave unlocked.
+
+        """
+        if not bbox.is_bbox:
+            raise ValueError("'bbox' is not a bbox")
+
+        BboxBase.__init__(self, **kwargs)
+        self._bbox = bbox
+        self.set_children(bbox)
+        self._points = None
+        fp = [x0, y0, x1, y1]
+        mask = [val is None for val in fp]
+        self._locked_points = np.ma.array(fp, np.float_,
+                                          mask=mask).reshape((2, 2))
+
+    def __repr__(self):
+        return "LockableBbox(%r, %r)" % (self._bbox, self._locked_points)
+
+    def get_points(self):
+        if self._invalid:
+            points = self._bbox.get_points()
+            self._points = np.where(self._locked_points.mask,
+                                    points,
+                                    self._locked_points)
+            self._invalid = 0
+        return self._points
+    get_points.__doc__ = Bbox.get_points.__doc__
+
+    if DEBUG:
+        _get_points = get_points
+
+        def get_points(self):
+            points = self._get_points()
+            self._check(points)
+            return points
+
+    @property
+    def locked_x0(self):
+        """
+        float or None: The value used for the locked x0.
+        """
+        if self._locked_points.mask[0, 0]:
+            return None
+        else:
+            return self._locked_points[0, 0]
+
+    @locked_x0.setter
+    def locked_x0(self, x0):
+        self._locked_points.mask[0, 0] = x0 is None
+        self._locked_points.data[0, 0] = x0
+        self.invalidate()
+
+    @property
+    def locked_y0(self):
+        """
+        float or None: The value used for the locked y0.
+        """
+        if self._locked_points.mask[0, 1]:
+            return None
+        else:
+            return self._locked_points[0, 1]
+
+    @locked_y0.setter
+    def locked_y0(self, y0):
+        self._locked_points.mask[0, 1] = y0 is None
+        self._locked_points.data[0, 1] = y0
+        self.invalidate()
+
+    @property
+    def locked_x1(self):
+        """
+        float or None: The value used for the locked x1.
+        """
+        if self._locked_points.mask[1, 0]:
+            return None
+        else:
+            return self._locked_points[1, 0]
+
+    @locked_x1.setter
+    def locked_x1(self, x1):
+        self._locked_points.mask[1, 0] = x1 is None
+        self._locked_points.data[1, 0] = x1
+        self.invalidate()
+
+    @property
+    def locked_y1(self):
+        """
+        float or None: The value used for the locked y1.
+        """
+        if self._locked_points.mask[1, 1]:
+            return None
+        else:
+            return self._locked_points[1, 1]
+
+    @locked_y1.setter
+    def locked_y1(self, y1):
+        self._locked_points.mask[1, 1] = y1 is None
+        self._locked_points.data[1, 1] = y1
+        self.invalidate()
+
+
 class Transform(TransformNode):
     """
     The base class of all :class:`TransformNode` instances that
