Significant speed improvement in text layout. Reverted to fix bug in

mdboom · mdboom · commit b6e9ae7b202b · 2007-10-15T13:49:25.000Z
ticklabels.  Lots of other minor things.

svn path=/branches/transforms/; revision=3947
diff --git a/lib/matplotlib/axes.py b/lib/matplotlib/axes.py
@@ -1037,6 +1037,7 @@ def add_artist(self, a):
         a.set_axes(self)
         self.artists.append(a)
         self._set_artist_props(a)
+        a.set_clip_path(self.axesPatch)
         a._remove_method = lambda h: self.artists.remove(h)
 
     def add_collection(self, collection, autolim=False):
@@ -1091,6 +1092,7 @@ def add_table(self, tab):
         'Add a table instance to the list of axes tables'
         self._set_artist_props(tab)
         self.tables.append(tab)
+        tab.set_clip_path(self.axesPatch)
         tab._remove_method = lambda h: self.tables.remove(h)
 
     def relim(self):
diff --git a/lib/matplotlib/axis.py b/lib/matplotlib/axis.py
@@ -91,7 +91,6 @@ def __init__(self, axes, loc, label,
         self._size = size
 
         self._padPixels = self.figure.dpi * self._pad * (1/72.0)
-        self._locTransform = Affine2D()
         
         self.tick1line = self._get_tick1line()
         self.tick2line = self._get_tick2line()
@@ -286,7 +285,7 @@ def _get_tick2line(self):
                        markersize=self._size,
                        )
 
-        l.set_transform(self._locTransform + self.axes.get_xaxis_transform())
+        l.set_transform(self.axes.get_xaxis_transform())
         self._set_artist_props(l)
         return l
 
@@ -298,16 +297,20 @@ def _get_gridline(self):
                    linestyle=rcParams['grid.linestyle'],
                    linewidth=rcParams['grid.linewidth'],
                    )
-        l.set_transform(self._locTransform + self.axes.get_xaxis_transform())
+        l.set_transform(self.axes.get_xaxis_transform())
         self._set_artist_props(l)
 
         return l
 
     def update_position(self, loc):
         'Set the location of tick in data coords with scalar loc'
-        self._locTransform.clear().translate(loc, 0.0)
-        self.label1.set_x(loc)
-        self.label2.set_x(loc)
+        x = loc
+
+        self.tick1line.set_xdata((x,))
+        self.tick2line.set_xdata((x,))
+        self.gridline.set_xdata((x, ))
+        self.label1.set_x(x)
+        self.label2.set_x(x)
         self._loc = loc
 
     def get_view_interval(self):
@@ -385,7 +388,7 @@ def _get_tick1line(self):
                     linestyle = 'None',
                     markersize=self._size,
                        )
-        l.set_transform(self._locTransform + self.axes.get_yaxis_transform())
+        l.set_transform(self.axes.get_yaxis_transform())
         self._set_artist_props(l)
         return l
 
@@ -398,7 +401,7 @@ def _get_tick2line(self):
                     markersize=self._size,
                     )
 
-        l.set_transform(self._locTransform + self.axes.get_yaxis_transform())
+        l.set_transform(self.axes.get_yaxis_transform())
         self._set_artist_props(l)
         return l
 
@@ -411,19 +414,24 @@ def _get_gridline(self):
                     linewidth=rcParams['grid.linewidth'],
                     )
 
-        l.set_transform(self._locTransform + self.axes.get_yaxis_transform())
+        l.set_transform(self.axes.get_yaxis_transform())
         self._set_artist_props(l)
         return l
 
 
     def update_position(self, loc):
         'Set the location of tick in data coords with scalar loc'
-        self._locTransform.clear().translate(0.0, loc)
-        self.label1.set_y(loc)
-        self.label2.set_y(loc)
-        self._loc = loc
+        y = loc
+        self.tick1line.set_ydata((y,))
+        self.tick2line.set_ydata((y,))
+        self.gridline.set_ydata((y, ))
 
+        self.label1.set_y( y )
+        self.label2.set_y( y )
 
+        self._loc = loc
+
+        
     def get_view_interval(self):
         'return the Interval instance for this axis view limits'
         return self.axes.viewLim.intervaly
@@ -751,7 +759,7 @@ def get_minor_ticks(self, numticks=None):
         if len(self.minorTicks) < numticks:
             # update the new tick label properties from the old
             for i in range(numticks - len(self.minorTicks)):
-                tick = self._get_tick(minor=True)
+                tick = self._get_tick(major=False)
                 self.minorTicks.append(tick)
             
         if self._lastNumMinorTicks < numticks:
diff --git a/lib/matplotlib/collections.py b/lib/matplotlib/collections.py
@@ -43,7 +43,7 @@ class Collection(artist.Artist, cm.ScalarMappable):
           linewidths=None,
           antialiaseds = None,
           offsets = None,
-          transOffset = transforms.identity_transform(),
+          transOffset = transforms.IdentityTransform(),
           norm = None,  # optional for cm.ScalarMappable
           cmap = None,  # ditto
 
@@ -376,7 +376,7 @@ def update_scalarmappable(self):
       linewidths=None,
       antialiaseds = None,
       offsets = None,
-      transOffset = transforms.identity_transform(),
+      transOffset = transforms.IdentityTransform(),
       norm = None,  # optional for cm.ScalarMappable
       cmap = None,  # ditto
 
diff --git a/lib/matplotlib/lines.py b/lib/matplotlib/lines.py
@@ -455,8 +455,10 @@ def draw(self, renderer):
         gc.set_capstyle(cap)
 
         funcname = self._lineStyles.get(self._linestyle, '_draw_nothing')
-        lineFunc = getattr(self, funcname)
-        lineFunc(renderer, gc, *self._transformed_path.get_transformed_path_and_affine())
+        if funcname != '_draw_nothing':
+            tpath, affine = self._transformed_path.get_transformed_path_and_affine()
+            lineFunc = getattr(self, funcname)
+            lineFunc(renderer, gc, tpath, affine)
 	    
         if self._marker is not None:
             gc = renderer.new_gc()
@@ -465,8 +467,10 @@ def draw(self, renderer):
             gc.set_linewidth(self._markeredgewidth)
             gc.set_alpha(self._alpha)
             funcname = self._markers.get(self._marker, '_draw_nothing')
-            markerFunc = getattr(self, funcname)
-            markerFunc(renderer, gc, *self._transformed_path.get_transformed_path_and_affine())
+            if funcname != '_draw_nothing':
+                tpath, affine = self._transformed_path.get_transformed_path_and_affine()
+                markerFunc = getattr(self, funcname)
+                markerFunc(renderer, gc, tpath, affine)
 
         renderer.close_group('line2d')
 
@@ -621,10 +625,8 @@ def set_xdata(self, x):
 
         ACCEPTS: npy.array
         """
-        try: del self._xsorted
-        except AttributeError: pass
-
-        self.set_data(x, self.get_ydata())
+        self._xorig = x
+        self.recache()
 
     def set_ydata(self, y):
         """
@@ -633,8 +635,8 @@ def set_ydata(self, y):
         ACCEPTS: npy.array
         """
 
-        self.set_data(self.get_xdata(), y)
-
+        self._yorig = y
+        self.recache()
 
     def set_dashes(self, seq):
         """
diff --git a/lib/matplotlib/path.py b/lib/matplotlib/path.py
@@ -84,7 +84,8 @@ def __init__(self, vertices, codes=None, closed=True):
         resulting path will be compressed, with MOVETO codes inserted
         in the correct places to jump over the masked regions.
         """
-        vertices = ma.asarray(vertices, npy.float_)
+        if not ma.isMaskedArray(vertices):
+            vertices = ma.asarray(vertices, npy.float_)
 
 	if codes is None:
             if len(vertices) == 0:
diff --git a/lib/matplotlib/text.py b/lib/matplotlib/text.py
@@ -172,68 +172,58 @@ def update_from(self, other):
         self._linespacing = other._linespacing
 
     def _get_layout(self, renderer):
-        # layout the xylocs in display coords as if angle = zero and
-        # then rotate them around self._x, self._y
-        #return _unit_box
         key = self.get_prop_tup()
         if self.cached.has_key(key): return self.cached[key]
-        horizLayout = []
-        transform = self.get_transform()
-        x, y = self.get_position()
-        thisx, thisy = transform.transform_point((x, y))
-        tx, ty = thisx, thisy
 
-        width = 0
-        height = 0
+        horizLayout = []
 
-        xmin, ymin = thisx, thisy
+        thisx, thisy  = 0.0, 0.0
+        xmin, ymin    = 0.0, 0.0
+        width, height = 0.0, 0.0
         lines = self._text.split('\n')
 
-        whs = []
+        whs = npy.zeros((len(lines), 2))
+        horizLayout = npy.zeros((len(lines), 4))
         # Find full vertical extent of font,
         # including ascenders and descenders:
         tmp, heightt, bl = renderer.get_text_width_height_descent(
                 'lp', self._fontproperties, ismath=False)
         offsety = heightt * self._linespacing
 
         baseline = None
-        for line in lines:
+        for i, line in enumerate(lines):
             w, h, d = renderer.get_text_width_height_descent(
                 line, self._fontproperties, ismath=self.is_math_text(line))
             if baseline is None:
                 baseline = h - d
-            whs.append( (w,h) )
-            horizLayout.append((line, thisx, thisy, w, h))
+            whs[i] = w, h
+            horizLayout[i] = thisx, thisy, w, h
             thisy -= offsety
             width = max(width, w)
 
-        ymin = horizLayout[-1][2]
-        ymax = horizLayout[0][2] + horizLayout[0][-1]
+        ymin = horizLayout[-1][1]
+        ymax = horizLayout[0][1] + horizLayout[0][3]
         height = ymax-ymin
-
         xmax = xmin + width
+
         # get the rotation matrix
-        M = self.get_rotation_matrix(xmin, ymin)
+        M = Affine2D().rotate_deg(self.get_rotation())
 
-        # the corners of the unrotated bounding box
-        cornersHoriz = npy.array(
-	    [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)],
-	    npy.float_)
         offsetLayout = npy.zeros((len(lines), 2))
+        offsetLayout[:] = horizLayout[:, 0:2]
         # now offset the individual text lines within the box
         if len(lines)>1: # do the multiline aligment
             malign = self._get_multialignment()
-            for i, (line, thisx, thisy, w, h) in enumerate(horizLayout):
-                if malign=='center': offsetx = width/2.0-w/2.0
-                elif malign=='right': offsetx = width-w
-                else: offsetx = 0
-                thisx += offsetx
-		offsetLayout[i] = (thisx, thisy)
-        else: # no additional layout needed
-            offsetLayout[0] = horizLayout[0][1:3]
+            if malign == 'center':
+                offsetLayout[:, 0] += width/2.0 - horizLayout[:, 2] / 2.0
+            elif malign == 'right':
+                offsetLayout[:, 0] += width - horizLayout[:, 2]
 
+        # the corners of the unrotated bounding box
+        cornersHoriz = npy.array(
+	    [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)],
+	    npy.float_)
         # now rotate the bbox
-
         cornersRotated = M.transform(cornersHoriz)
 
         txs = cornersRotated[:, 0]
@@ -251,37 +241,30 @@ def _get_layout(self, renderer):
 
         # compute the text location in display coords and the offsets
         # necessary to align the bbox with that location
-        tx, ty = self._get_xy_display()
-
-        if halign=='center':  offsetx = tx - (xmin + width/2.0)
-        elif halign=='right': offsetx = tx - (xmin + width)
-        else: offsetx = tx - xmin
+        if halign=='center':  offsetx = (xmin + width/2.0)
+        elif halign=='right': offsetx = (xmin + width)
+        else: offsetx = xmin
 
-        if valign=='center': offsety = ty - (ymin + height/2.0)
-        elif valign=='top': offsety  = ty - (ymin + height)
-        elif valign=='baseline': offsety = ty - (ymin + height) + baseline
-        else: offsety = ty - ymin
+        if valign=='center': offsety = (ymin + height/2.0)
+        elif valign=='top': offsety  = (ymin + height)
+        elif valign=='baseline': offsety = (ymin + height) + baseline
+        else: offsety = ymin
 
-        xmin += offsetx
-        ymin += offsety
+        xmin -= offsetx
+        ymin -= offsety
 
         bbox = Bbox.from_lbwh(xmin, ymin, width, height)
 
         # now rotate the positions around the first x,y position
         xys = M.transform(offsetLayout)
-        xys += (offsetx, offsety)
-
-        # now inverse transform back to data coords
-	inverse_transform = transform.inverted()
-        xys = inverse_transform.transform(xys)
+        xys -= (offsetx, offsety)
 
         xs, ys = xys[:, 0], xys[:, 1]
         
         ret = bbox, zip(lines, whs, xs, ys)
         self.cached[key] = ret
         return ret
 
-
     def set_bbox(self, rectprops):
         """
         Draw a bounding box around self.  rect props are any settable
@@ -307,28 +290,30 @@ def draw(self, renderer):
         if self.get_clip_on():
             gc.set_clip_rectangle(self.clipbox)
 
-
-
         if self._bbox:
             bbox_artist(self, renderer, self._bbox)
         angle = self.get_rotation()
 
         bbox, info = self._get_layout(renderer)
         trans = self.get_transform()
+        posx, posy = self.get_position()
+        posx, posy = trans.transform_point((posx, posy))
+        canvasw, canvash = renderer.get_canvas_width_height()
+        
         if rcParams['text.usetex']:
-            canvasw, canvash = renderer.get_canvas_width_height()
             for line, wh, x, y in info:
-                x, y = trans.transform_point((x, y))
+                x = x + posx
+                y = y + posy
                 if renderer.flipy():
                     y = canvash-y
 
                 renderer.draw_tex(gc, x, y, line,
                                   self._fontproperties, angle)
             return
 
-        canvasw, canvash = renderer.get_canvas_width_height()
         for line, wh, x, y in info:
-            x, y = trans.transform_point((x, y))
+            x = x + posx
+            y = y + posy
             if renderer.flipy():
                 y = canvash-y
                 
@@ -402,8 +387,7 @@ def get_prop_tup(self):
         x, y = self.get_position()
         return (x, y, self._text, self._color,
                 self._verticalalignment, self._horizontalalignment,
-                hash(self._fontproperties), self._rotation,
-                self.get_transform().id
+                hash(self._fontproperties), self._rotation
                 )
 
     def get_text(self):
@@ -432,11 +416,11 @@ def get_window_extent(self, renderer=None):
 
         angle = self.get_rotation()
         bbox, info = self._get_layout(self._renderer)
+        x, y = self.get_position()
+        x, y = self.get_transform().transform_point((x, y))
+        bbox = bbox.translated(x, y)
         return bbox
 
-    def get_rotation_matrix(self, x0, y0):
-	return Affine2D().rotate_deg_around(x0, y0, self.get_rotation())
-
     def set_backgroundcolor(self, color):
         """
         Set the background color of the text by updating the bbox (see set_bbox for more info)
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
