Simplify Annotation and Text bbox drawing.

anntzer · anntzer · commit d79dfaa8aed0 · 2020-05-08T01:46:07.000+02:00
Currently Annotation.draw goes through _check_xy to check whether the
annotation should be drawn at all, and then through
_update_position_xytext to position itself.  In order to save a single
call to _get_position_xy, it first calls _get_position_xy itself and
then passes it down to the helper functions, making them harder to
follow.  Instead, just let _check_xy call _get_position_xy itself (and
even then, this is only needed for some values of annotation_clip), and
likewise for _update_position_xytext (which just becomes a call to
update_positions).

Also a small shortening of Text.update_bbox_position_size.
diff --git a/lib/matplotlib/offsetbox.py b/lib/matplotlib/offsetbox.py
@@ -1507,28 +1507,21 @@ def contains(self, mouseevent):
         inside, info = self._default_contains(mouseevent)
         if inside is not None:
             return inside, info
-
-        xy_pixel = self._get_position_xy(None)
-        if not self._check_xy(None, xy_pixel):
+        if not self._check_xy(None):
             return False, {}
-
-        t, tinfo = self.offsetbox.contains(mouseevent)
+        return self.offsetbox.contains(mouseevent)
         #if self.arrow_patch is not None:
         #    a, ainfo=self.arrow_patch.contains(event)
         #    t = t or a
-
         # self.arrow_patch is currently not checked as this can be a line - JJ
 
-        return t, tinfo
-
     def get_children(self):
         children = [self.offsetbox, self.patch]
         if self.arrow_patch:
             children.append(self.arrow_patch)
         return children
 
     def set_figure(self, fig):
-
         if self.arrow_patch is not None:
             self.arrow_patch.set_figure(fig)
         self.offsetbox.set_figure(fig)
@@ -1623,23 +1616,15 @@ def _update_position_xybox(self, renderer, xy_pixel):
 
     def draw(self, renderer):
         # docstring inherited
-
         if renderer is not None:
             self._renderer = renderer
-        if not self.get_visible():
+        if not self.get_visible() or not self._check_xy(renderer):
             return
-
-        xy_pixel = self._get_position_xy(renderer)
-        if not self._check_xy(renderer, xy_pixel):
-            return
-
         self.update_positions(renderer)
-
         if self.arrow_patch is not None:
             if self.arrow_patch.figure is None and self.figure is not None:
                 self.arrow_patch.figure = self.figure
             self.arrow_patch.draw(renderer)
-
         self.patch.draw(renderer)
         self.offsetbox.draw(renderer)
         self.stale = False
diff --git a/lib/matplotlib/text.py b/lib/matplotlib/text.py
@@ -502,10 +502,10 @@ def update_bbox_position_size(self, renderer):
 
             x_box, y_box, w_box, h_box = _get_textbox(self, renderer)
             self._bbox_patch.set_bounds(0., 0., w_box, h_box)
-            theta = np.deg2rad(self.get_rotation())
-            tr = Affine2D().rotate(theta)
-            tr = tr.translate(posx + x_box, posy + y_box)
-            self._bbox_patch.set_transform(tr)
+            self._bbox_patch.set_transform(
+                Affine2D()
+                .rotate_deg(self.get_rotation())
+                .translate(posx + x_box, posy + y_box))
             fontsize_in_pixel = renderer.points_to_pixels(self.get_size())
             self._bbox_patch.set_mutation_scale(fontsize_in_pixel)
 
@@ -1481,11 +1481,12 @@ def _get_position_xy(self, renderer):
         x, y = self.xy
         return self._get_xy(renderer, x, y, self.xycoords)
 
-    def _check_xy(self, renderer, xy_pixel):
+    def _check_xy(self, renderer):
         """Check whether the annotation at *xy_pixel* should be drawn."""
         b = self.get_annotation_clip()
         if b or (b is None and self.xycoords == "data"):
             # check if self.xy is inside the axes.
+            xy_pixel = self._get_position_xy(renderer)
             return self.axes.contains_point(xy_pixel)
         return True
 
@@ -1811,21 +1812,16 @@ def set_figure(self, fig):
         Artist.set_figure(self, fig)
 
     def update_positions(self, renderer):
-        """Update the pixel positions of the annotated point and the text."""
-        xy_pixel = self._get_position_xy(renderer)
-        self._update_position_xytext(renderer, xy_pixel)
-
-    def _update_position_xytext(self, renderer, xy_pixel):
         """
         Update the pixel positions of the annotation text and the arrow patch.
         """
+        x1, y1 = self._get_position_xy(renderer)  # Annotated position.
         # generate transformation,
         self.set_transform(self._get_xy_transform(renderer, self.anncoords))
 
         if self.arrowprops is None:
             return
 
-        x1, y1 = xy_pixel  # Annotated position.
         bbox = Text.get_window_extent(self, renderer)
 
         d = self.arrowprops.copy()
@@ -1893,24 +1889,16 @@ def _update_position_xytext(self, renderer, xy_pixel):
     @artist.allow_rasterization
     def draw(self, renderer):
         # docstring inherited
-
         if renderer is not None:
             self._renderer = renderer
-        if not self.get_visible():
-            return
-
-        xy_pixel = self._get_position_xy(renderer)
-        if not self._check_xy(renderer, xy_pixel):
+        if not self.get_visible() or not self._check_xy(renderer):
             return
-
-        self._update_position_xytext(renderer, xy_pixel)
+        self.update_positions(renderer)
         self.update_bbox_position_size(renderer)
-
         if self.arrow_patch is not None:   # FancyArrowPatch
             if self.arrow_patch.figure is None and self.figure is not None:
                 self.arrow_patch.figure = self.figure
             self.arrow_patch.draw(renderer)
-
         # Draw text, including FancyBboxPatch, after FancyArrowPatch.
         # Otherwise, a wedge arrowstyle can land partly on top of the Bbox.
         Text.draw(self, renderer)
