fixed an aspect=auto problem with bezier ellipse approx

svn path=/trunk/matplotlib/; revision=3949

Author: jdh2358

CHANGELOG

@@ -1,3 +1,12 @@
+2007-10-15 Fixed a bug in patches.Ellipse that was broken for
+           aspect='auto'.  Scale free ellipses now work properly for
+           equal and auto on Agg and PS, and they fall back on a
+           polygonal approximation for nonlinear transformations until
+           we convince oursleves that the spline approximation holds
+           for nonlinear transformations. Added
+           unit/ellipse_compare.py to compare spline with vertex
+           approx for both aspects. JDH
+
 2007-10-05 remove generator expressions from texmanager and mpltraits. 
            generator expressions are not supported by python-2.3 - DSD
 

boilerplate.py

@@ -2,8 +2,7 @@
 # file is pasted into pylab.py.  We did try to do this the smart way,
 # with callable functions and new.function, but could never get the
 # docstrings right for python2.2.  See
-# http://groups-beta.google.com/group/comp.lang.python/messages/1b14640f3a4ad3dc,b3d7453af21e5f82,17739e70ac6f710c,9d5291fce29cbbb1,c5b578e4ffc6af28,056ff270daa2f414?thread_id=dcd63ec13096a0f6&mode=thread
-
+# http://groups.google.com/group/comp.lang.python/browse_frm/thread/dcd63ec13096a0f6/1b14640f3a4ad3dc?#1b14640f3a4ad3dc
 
 
 # note we check for __doc__ is not None since py2exe optimize removes

lib/matplotlib/backends/backend_ps.py

@@ -329,7 +329,7 @@ def _get_font_ttf(self, prop):
         size = prop.get_size_in_points()
         font.set_size(size, 72.0)
         return font
-
+        
     def draw_arc(self, gc, rgbFace, x, y, width, height, angle1, angle2, rotation):
         """
         Draw an arc centered at x,y with width and height and angles
@@ -340,7 +340,7 @@ def draw_arc(self, gc, rgbFace, x, y, width, height, angle1, angle2, rotation):
         """
         ps = '%f %f translate\n%f rotate\n%f %f translate\n%s ellipse' % \
             (x, y, rotation, -x, -y, _nums_to_str(angle1, angle2, 0.5*width, 0.5*height, x, y))
-        self._draw_ps(ps, gc, rgbFace, "arc")
+        self._draw_ps(ps, gc, None, "arc")
 
     def _rgba(self, im):
         return im.as_rgba_str()
@@ -519,8 +519,41 @@ def drawone(x, y):
             end += step
         if cliprect: write('grestore\n')
 
-    def draw_path(self,gc,rgbFace,path,trans):
-        pass
+    def draw_path(self, gc, rgbFace, path):
+
+        ps_cmd = []
+        ps_cmd.append('newpath')
+        
+        while 1:
+            code, xp, yp = path.vertex()
+
+            #print code, xp, yp
+            
+            if code == agg.path_cmd_stop:
+                ps_cmd.append('closepath') # Hack, path_cmd_end_poly not found
+                break
+            elif code == agg.path_cmd_move_to:
+                ps_cmd.append('%g %g m' % (xp,yp))
+            elif code == agg.path_cmd_line_to:
+                ps_cmd.append('%g %g l' % (xp,yp))
+            elif code == agg.path_cmd_curve3:
+                pass
+            elif code == agg.path_cmd_curve4:
+                verts = [xp, yp]
+                verts.extend(path.vertex()[1:])
+                verts.extend(path.vertex()[1:])
+                ps_cmd.append('%g %g %g %g %g %g curveto'%tuple(verts))
+            elif code == agg.path_cmd_end_poly:
+                ps_cmd.append('closepath')
+            elif code == agg.path_cmd_mask:
+                pass
+            else:
+                pass
+                #print code
+
+        ps = '\n'.join(ps_cmd)
+
+        self._draw_ps(ps, gc, rgbFace, "custom_path")
 
     def draw_lines(self, gc, x, y, transform):
         """
@@ -883,6 +916,7 @@ def _draw_ps(self, ps, gc, rgbFace, command=None):
         # local variable eliminates all repeated attribute lookups
         write = self._pswriter.write
         write('gsave\n')
+
         if debugPS and command:
             write("% "+command+"\n")
 
@@ -916,6 +950,7 @@ def _draw_ps(self, ps, gc, rgbFace, command=None):
         if cliprect:
             write("grestore\n")
         write('grestore\n')            
+
     def push_gc(self, gc, store=1):
         """
         Push the current onto stack, with the exception of the clip box, which
@@ -1581,5 +1616,15 @@ class FigureManagerPS(FigureManagerBase):
       0 0 1 5 3 roll arc
       setmatrix
       closepath
-    } bind def"""
+    } bind def""",
+    """/unitcircle {
+    newpath
+-1. 0. moveto
+-1.0 0.552284749831 -0.552284749831 1.0 0.0 1.0 curveto
+0.552284749831 1.0 1.0 0.552284749831 1.0 0.0 curveto
+1.0 -0.552284749831 0.552284749831 -1.0 0.0 -1.0 curveto
+-0.552284749831 -1.0 -1.0 -0.552284749831 -1.0 0.0 curveto
+closepath
+    } bind def""",
+    
 ]

lib/matplotlib/cbook.py

@@ -230,17 +230,18 @@ def is_numlike(obj):
     except TypeError: return False
     else: return True
 
-def to_filehandle(fname):
+def to_filehandle(fname, flag='r'):
     """
     fname can be a filename or a file handle.  Support for gzipped
-    files is automatic, if the filename ends in .gz
+    files is automatic, if the filename ends in .gz.  flag is a
+    read/write flag for file
     """
     if is_string_like(fname):
         if fname.endswith('.gz'):
             import gzip
-            fh = gzip.open(fname)
+            fh = gzip.open(fname, flag)
         else:
-            fh = file(fname)
+            fh = file(fname, flag)
     elif hasattr(fname, 'seek'):
         fh = fname
     else:

lib/matplotlib/mlab.py

@@ -809,6 +809,8 @@ def prctile(x, p = (0.0, 25.0, 50.0, 75.0, 100.0)):
     If p is a scalar, the largest value of x less than or equal
     to the p percentage point in the sequence is returned.
     """
+
+
     x = npy.ravel(x)
     x.sort()
     Nx = len(x)
@@ -1282,7 +1284,10 @@ def csv2rec(fname, comments='#', skiprows=0, checkrows=5, delimiter=',',
     converterd, if not None, is a dictionary mapping column number or
     munged column name to a converter function
 
-    See examples/loadrec.py
+    names, if not None, is a list of header names.  In this case, no
+    header will be read from the file
+
+    if no rows are found, None is returned See examples/loadrec.py
     """
 
     if converterd is None:
@@ -1291,9 +1296,42 @@ def csv2rec(fname, comments='#', skiprows=0, checkrows=5, delimiter=',',
     import dateutil.parser
     parsedate = dateutil.parser.parse
 
+
     fh = cbook.to_filehandle(fname)
-    reader = csv.reader(fh, delimiter=delimiter)
 
+    
+    class FH:
+        """
+        for space delimited files, we want different behavior than
+        comma or tab.  Generally, we want multiple spaces to be
+        treated as a single separator, whereas with comma and tab we
+        want multiple commas to return multiple (empty) fields.  The
+        join/strip trick below effects this
+        """
+        def __init__(self, fh):
+            self.fh = fh
+
+        def close(self):
+            self.fh.close()
+
+        def seek(self, arg):
+            self.fh.seek(arg)
+
+        def fix(self, s):
+            return ' '.join(s.split())
+
+
+        def next(self):
+            return self.fix(self.fh.next())
+
+        def __iter__(self):
+            for line in self.fh:            
+                yield self.fix(line)
+
+    if delimiter==' ':
+        fh = FH(fh)
+
+    reader = csv.reader(fh, delimiter=delimiter)        
     def process_skiprows(reader):
         if skiprows:
             for i, row in enumerate(reader):
@@ -1388,9 +1426,131 @@ def get_converters(reader):
         rows.append([func(val) for func, val in zip(converters, row)])
     fh.close()
 
+    if not len(rows):
+        return None
     r = npy.rec.fromrecords(rows, names=names)
     return r
 
+
+def rec2csv(r, fname, delimiter=','):
+    """
+    Save the data from numpy record array r into a comma/space/tab
+    delimited file.  The record array dtype names will be used for
+    column headers.
+
+
+    fname - can be a filename or a file handle.  Support for gzipped
+    files is automatic, if the filename ends in .gz
+    """
+    fh = cbook.to_filehandle(fname, 'w')
+    writer = csv.writer(fh, delimiter=delimiter)
+    header = r.dtype.names
+    writer.writerow(header)
+    for row in r:
+        writer.writerow(map(str, row))
+    fh.close()
+
+# some record array helpers
+def rec_append_field(rec, name, arr, dtype=None):
+    'return a new record array with field name populated with data from array arr'
+    arr = npy.asarray(arr)
+    if dtype is None:
+        dtype = arr.dtype
+    newdtype = npy.dtype(rec.dtype.descr + [(name, dtype)])
+    newrec = npy.empty(rec.shape, dtype=newdtype)
+    for field in rec.dtype.fields:
+        newrec[field] = rec[field]
+    newrec[name] = arr
+    return newrec.view(npy.recarray)
+
+  
+def rec_drop_fields(rec, names):
+    'return a new numpy record array with fields in names dropped'    
+
+    names = set(names)
+    Nr = len(rec)
+    
+    newdtype = npy.dtype([(name, rec.dtype[name]) for name in rec.dtype.names
+                       if name not in names])
+
+    newrec = npy.empty(Nr, dtype=newdtype)
+    for field in newdtype.names:
+        newrec[field] = rec[field]
+
+    return newrec.view(npy.recarray)
+
+    
+def rec_join(key, r1, r2):
+    """
+    join record arrays r1 and r2 on key; key is a tuple of field
+    names.  if r1 and r2 have equal values on all the keys in the key
+    tuple, then their fields will be merged into a new record array
+    containing the union of the fields of r1 and r2
+    """
+
+    for name in key:
+        if name not in r1.dtype.names:
+            raise ValueError('r1 does not have key field %s'%name)
+        if name not in r2.dtype.names:
+            raise ValueError('r2 does not have key field %s'%name)
+
+    def makekey(row):
+        return tuple([row[name] for name in key])
+
+  
+    names = list(r1.dtype.names) + [name for name in r2.dtype.names if name not in set(r1.dtype.names)]
+ 
+
+    
+    r1d = dict([(makekey(row),i) for i,row in enumerate(r1)])        
+    r2d = dict([(makekey(row),i) for i,row in enumerate(r2)])
+
+    r1keys = set(r1d.keys())    
+    r2keys = set(r2d.keys())
+
+    keys = r1keys & r2keys
+
+    r1ind = [r1d[k] for k in keys]
+    r2ind = [r2d[k] for k in keys]
+
+    
+    r1 = r1[r1ind]
+    r2 = r2[r2ind]
+
+    r2 = rec_drop_fields(r2, r1.dtype.names)
+
+
+    def key_desc(name):
+        'if name is a string key, use the larger size of r1 or r2 before merging'
+        dt1 = r1.dtype[name]
+        if dt1.type != npy.string_:
+            return (name, dt1.descr[0][1])
+
+        dt2 = r1.dtype[name]
+        assert dt2==dt1
+        if dt1.num>dt2.num:
+            return (name, dt1.descr[0][1])
+        else:
+            return (name, dt2.descr[0][1])
+
+        
+        
+    keydesc = [key_desc(name) for name in key]
+
+    newdtype = npy.dtype(keydesc +
+                         [desc for desc in r1.dtype.descr if desc[0] not in key ] +
+                         [desc for desc in r2.dtype.descr if desc[0] not in key ] )
+                         
+    
+    newrec = npy.empty(len(r1), dtype=newdtype)
+    for field in r1.dtype.names:
+        newrec[field] = r1[field]
+
+    for field in r2.dtype.names:
+        newrec[field] = r2[field]
+
+    return newrec.view(npy.recarray)
+
 def slopes(x,y):
     """
     SLOPES calculate the slope y'(x) Given data vectors X and Y SLOPES