implement Axis.get_tightbbox and account offsetText in calculating

leejjoon · leejjoon · commit 635cf1f07537 · 2011-05-16T07:50:18.000+09:00
diff --git a/lib/matplotlib/axes.py b/lib/matplotlib/axes.py
@@ -8343,24 +8343,19 @@ def get_tightbbox(self, renderer):
         artists = []
         bb = []
 
-        artists.append(self)
+        if not self.get_visible():
+            return None
 
-        if self.title.get_visible():
-            artists.append(self.title)
+        bb.append(self.get_window_extent(renderer))
 
-        if self.xaxis.get_visible():
-            artists.append(self.xaxis.label)
-            bbx1, bbx2 = self.xaxis.get_ticklabel_extents(renderer)
-            self.xaxis._update_label_position([bbx1], [bbx2])
-            bb.extend([bbx1, bbx2])
-        if self.yaxis.get_visible():
-            artists.append(self.yaxis.label)
-            bby1, bby2 = self.yaxis.get_ticklabel_extents(renderer)
-            self.yaxis._update_label_position([bby1], [bby2])
-            bb.extend([bby1, bby2])
+        if self.title.get_visible():
+            bb.append(self.title.get_window_extent(renderer))
 
+        bb_xaxis = self.xaxis.get_tightbbox(renderer)
+        if bb_xaxis: bb.append(bb_xaxis)
 
-        bb.extend([c.get_window_extent(renderer) for c in artists if c.get_visible()])
+        bb_yaxis = self.yaxis.get_tightbbox(renderer)
+        if bb_yaxis: bb.append(bb_yaxis)
 
         _bbox = mtransforms.Bbox.union([b for b in bb if b.width!=0 or b.height!=0])
 
diff --git a/lib/matplotlib/axis.py b/lib/matplotlib/axis.py
@@ -888,7 +888,7 @@ def iter_ticks(self):
             for tick in zip(*group):
                 yield tick
 
-    def get_ticklabel_extents(self, renderer):
+    def get_ticklabel_extents_old(self, renderer):
         """
         Get the extents of the tick labels on either side
         of the axes.
@@ -920,6 +920,26 @@ def get_ticklabel_extents(self, renderer):
             bbox2 = mtransforms.Bbox.from_extents(0, 0, 0, 0)
         return bbox, bbox2
 
+
+    def get_ticklabel_extents(self, renderer):
+        """
+        Get the extents of the tick labels on either side
+        of the axes.
+        """
+
+        ticks_to_draw = self._update_ticks(renderer)
+        ticklabelBoxes, ticklabelBoxes2 = self._get_tick_bboxes(ticks_to_draw, renderer)
+
+        if len(ticklabelBoxes):
+            bbox = mtransforms.Bbox.union(ticklabelBoxes)
+        else:
+            bbox = mtransforms.Bbox.from_extents(0, 0, 0, 0)
+        if len(ticklabelBoxes2):
+            bbox2 = mtransforms.Bbox.union(ticklabelBoxes2)
+        else:
+            bbox2 = mtransforms.Bbox.from_extents(0, 0, 0, 0)
+        return bbox, bbox2
+
     def set_smart_bounds(self,value):
         """set the axis to have smart bounds"""
         self._smart_bounds = value
@@ -928,14 +948,13 @@ def get_smart_bounds(self):
         """get whether the axis has smart bounds"""
         return self._smart_bounds
 
-    @allow_rasterization
-    def draw(self, renderer, *args, **kwargs):
-        'Draw the axis lines, grid lines, tick lines and labels'
-        ticklabelBoxes = []
-        ticklabelBoxes2 = []
+    def _update_ticks(self, renderer):
+        """
+        Update ticks (position and labels) using the current data
+        interval of the axes. Returns a list of ticks that will be
+        drawn.
+        """
 
-        if not self.get_visible(): return
-        renderer.open_group(__name__)
         interval = self.get_view_interval()
         tick_tups = [ t for t in self.iter_ticks()]
         if self._smart_bounds:
@@ -977,19 +996,81 @@ def draw(self, renderer, *args, **kwargs):
                 tick_tups = [ ti for ti in tick_tups
                               if (ti[1] >= ilow) and (ti[1] <= ihigh)]
 
+        ticks_to_draw = []
         for tick, loc, label in tick_tups:
             if tick is None: continue
             if not mtransforms.interval_contains(interval, loc): continue
             tick.update_position(loc)
             tick.set_label1(label)
             tick.set_label2(label)
-            tick.draw(renderer)
+            ticks_to_draw.append(tick)
+
+        return ticks_to_draw
+
+    def _get_tick_bboxes(self, ticks, renderer):
+        """
+        Given the list of ticks, return two lists of bboxes. One for
+        tick lable1's and another for tick label2's.
+        """
+
+        ticklabelBoxes = []
+        ticklabelBoxes2 = []
+
+        for tick in ticks:
             if tick.label1On and tick.label1.get_visible():
                 extent = tick.label1.get_window_extent(renderer)
                 ticklabelBoxes.append(extent)
             if tick.label2On and tick.label2.get_visible():
                 extent = tick.label2.get_window_extent(renderer)
                 ticklabelBoxes2.append(extent)
+        return ticklabelBoxes, ticklabelBoxes2
+
+    def get_tightbbox(self, renderer):
+        """
+        Return a bounding box that encloses the axis. It only accounts
+        tick labels, axis label, and offsetText.
+        """
+        if not self.get_visible(): return
+
+        ticks_to_draw = self._update_ticks(renderer)
+        ticklabelBoxes, ticklabelBoxes2 = self._get_tick_bboxes(ticks_to_draw, renderer)
+
+        self._update_label_position(ticklabelBoxes, ticklabelBoxes2)
+
+        self._update_offset_text_position(ticklabelBoxes, ticklabelBoxes2)
+        self.offsetText.set_text( self.major.formatter.get_offset() )
+
+
+        bb = []
+
+        for a in [self.label, self.offsetText]:
+            if a.get_visible():
+                bb.append(a.get_window_extent(renderer))
+
+        bb.extend(ticklabelBoxes)
+        bb.extend(ticklabelBoxes2)
+
+        #self.offsetText
+        bb = [b for b in bb if b.width!=0 or b.height!=0]
+        if bb:
+            _bbox = mtransforms.Bbox.union(bb)
+            return _bbox
+        else:
+            return None
+
+
+    @allow_rasterization
+    def draw(self, renderer, *args, **kwargs):
+        'Draw the axis lines, grid lines, tick lines and labels'
+
+        if not self.get_visible(): return
+        renderer.open_group(__name__)
+
+        ticks_to_draw = self._update_ticks(renderer)
+        ticklabelBoxes, ticklabelBoxes2 = self._get_tick_bboxes(ticks_to_draw, renderer)
+
+        for tick in ticks_to_draw:
+            tick.draw(renderer)
 
         # scale up the axis label box to also find the neighbors, not
         # just the tick labels that actually overlap note we need a
