used seq proto in collection agg methods

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

Author: jdh2358

CHANGELOG

@@ -1,6 +1,16 @@
 New entries should be added at the top
 
-2005-02-121 fixed ps color bug - JDH
+2005-02-23 Used sequence protocol rather than tuple in agg collection
+           drawing routines for greater flexibility - JDH
+
+
+===========================================================
+2005-02-22 0.72.1 released
+
+2005-02-21 fixed linestyles for collections -- contour now dashes for
+           levels <0
+
+2005-02-21 fixed ps color bug - JDH
 
 2005-02-15 fixed missing qt file
 

lib/matplotlib/__init__.py

@@ -141,7 +141,7 @@
 """
 from __future__ import generators
 
-__version__  = '0.72'
+__version__  = '0.73'
 __revision__ = '$Revision$'
 __date__     = '$Date$'
 

lib/matplotlib/axes.py

@@ -1185,10 +1185,8 @@ def initialize_reg_tri(z):
             col = LineCollection(nlist)
             col.set_color(color)
             col.set_linewidth(width)
-            """
             if level < 0:
                 col.set_linestyle((0, (6.,6.)),)
-            """
             col.set_label(fmt%level)
             self.add_collection(col)
             levels.append(level)

lib/matplotlib/collections.py

@@ -395,6 +395,12 @@ def set_alpha(self, alpha):
     def get_linewidths(self):
         return self._lw
 
+    def get_linestyle(self):
+        return self._ls
+
+    def get_dashes(self):
+        return self._ls
+
     def get_colors(self):
         return self._colors
 

lib/matplotlib/legend.py

@@ -237,10 +237,11 @@ def _get_handles(self, handles, texts):
                 self._set_artist_props(legline)
                 legline.set_clip_box(None)
                 lw = handle.get_linewidths()[0]
-                style = handle.get_linewidths()[0]
+                dashes = handle.get_dashes()
                 color = handle.get_colors()[0]                
                 legline.set_color(color)
                 legline.set_linewidth(lw)
+                legline.set_dashes(dashes)
                 ret.append(legline)
 
 	    else:

lib/matplotlib/lines.py

@@ -139,8 +139,6 @@ def __init__(self, xdata, ydata,
             raise ValueError('Unrecognized marker style %s, %s'%( marker, type(marker)))
 
         self.set_marker(marker)
-        self._lineFunc = self._lineStyles.get(linestyle, self._draw_nothing)
-        self._markerFunc = self._markers.get(marker, self._draw_nothing)
 
         self._logcache = None
 
@@ -280,7 +278,8 @@ def draw(self, renderer):
             xt, yt = self._transform.numerix_x_y(x, y)
 
 
-        lineFunc = getattr(self, self._lineFunc)
+        funcname = self._lineStyles.get(self._linestyle, '_draw_nothing')
+        lineFunc = getattr(self, funcname)
         lineFunc(renderer, gc, xt, yt)
 
 
@@ -290,7 +289,8 @@ def draw(self, renderer):
             gc.set_linewidth(self._markeredgewidth)
             if self.get_clip_on():
                 gc.set_clip_rectangle(self.clipbox.get_bounds())
-            markerFunc = getattr(self, self._markerFunc)
+            funcname = self._markers.get(self._marker, '_draw_nothing')
+            markerFunc = getattr(self, funcname)
             markerFunc(renderer, gc, xt, yt)
 
         #if 1: bbox_artist(self, renderer)
@@ -395,7 +395,7 @@ def set_linestyle(self, s):
 ACCEPTS: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' ]
         """
         self._linestyle = s
-        self._lineFunc = self._lineStyles.get(self._linestyle, '-')
+
 
     def set_marker(self, marker):
         """
@@ -405,7 +405,6 @@ def set_marker(self, marker):
 
 """
         self._marker = marker
-        self._markerFunc = self._markers.get(marker, self._draw_nothing)
 
     def set_markeredgecolor(self, ec):
         """
@@ -497,7 +496,11 @@ def set_dashes(self, seq):
 
 ACCEPTS: sequence of on/off ink in points
 """
-        self._dashSeq = seq
+        if seq == (None, None):
+            self.set_linestyle('-')
+        else:
+            self.set_linestyle('--')
+        self._dashSeq = seq[1]  # TODO: offset ignroed for now
 
     def _draw_nothing(self, renderer, gc, xt, yt):
         pass
@@ -1055,8 +1058,6 @@ def update_from(self, other):
 
         self._linestyle = other._linestyle
         self._marker = other._marker
-        self._lineFunc = other._lineStyles[other._linestyle]
-        self._markerFunc = other._markers[other._marker]
         self._useDataClipping = other._useDataClipping
 
     def _get_rgb_face(self):

src/_backend_agg.cpp

@@ -391,12 +391,6 @@ RendererAgg::draw_line_collection(const Py::Tuple& args) {
   //segments, trans, clipbox, colors, linewidths, antialiaseds
   Py::SeqBase<Py::Object> segments = args[0];  
 
-  /* this line is broken, mysteriously
-     if (!Transformation::check(args[1])) 
-     throw Py::TypeError("RendererAgg::draw_line_collection(segments, transform, ...) expected a Transformation instance for transform");
-     
-  */
-  
   Transformation* transform = static_cast<Transformation*>(args[1].ptr());
 
   set_clip_from_bbox(args[2]);
@@ -420,8 +414,9 @@ RendererAgg::draw_line_collection(const Py::Tuple& args) {
   size_t Naa = antialiaseds.length();
   size_t Noffsets = 0;
   size_t N = Nsegments;
+  size_t Ndash = 0;
 
-  Py::Tuple dashtup(linestyle);
+  Py::SeqBase<Py::Object> dashtup(linestyle);
   bool useDashes = dashtup[0].ptr() != Py_None;
 
   double offset = 0;
@@ -435,14 +430,14 @@ RendererAgg::draw_line_collection(const Py::Tuple& args) {
     offset = points_to_pixels_snapto(dashtup[0]);
     dashSeq = dashtup[1]; 
 
-    size_t N = dashSeq.length();
-    if (N%2 != 0  ) 
+    Ndash = dashSeq.length();
+    if (Ndash%2 != 0  ) 
       throw Py::ValueError(Printf("dashes must be an even length sequence; found %d", N).str());     
 
-    dasha = new double[N];    
+    dasha = new double[Ndash];    
 
-    for (size_t i=0; i<N; i++) 
-      dasha[i] = points_to_pixels_snapto(dashSeq[i]);
+    for (size_t i=0; i<Ndash; i++) 
+      dasha[i] = points_to_pixels(dashSeq[i]);
   }  
 
 
@@ -453,11 +448,11 @@ RendererAgg::draw_line_collection(const Py::Tuple& args) {
 
   double xo(0.0), yo(0.0), thisx(0.0), thisy(0.0);
   std::pair<double, double> xy;  
-  Py::Tuple xyo;
+  Py::SeqBase<Py::Object> xyo;
   Py::SeqBase<Py::Object> xys;
   for (size_t i=0; i<N; ++i) {
     if (usingOffsets) {
-      xyo = Py::Tuple(offsets[i%Noffsets]);
+      xyo = Py::SeqBase<Py::Object>(offsets[i%Noffsets]);
       xo = Py::Float(xyo[0]);
       yo = Py::Float(xyo[1]);
       try {
@@ -516,32 +511,9 @@ RendererAgg::draw_line_collection(const Py::Tuple& args) {
     }
     else {
 
-      /*
-	size_t N = dashSeq.length();
-	if (N%2 != 0  ) 
-	throw Py::ValueError(Printf("dashes must be an even length sequence; found %d", N).str());     
-	
-	typedef agg::conv_dash<agg::path_storage> dash_t;
-	dash_t dash(path);
-	
-	double on, off;
-	
-	//dash.dash_start(offset);
-	for (size_t i=0; i<N/2; i+=1) {
-	on = points_to_pixels_snapto(dashSeq[2*i]);
-	off = points_to_pixels_snapto(dashSeq[2*i+1]);
-	dash.add_dash(on, off);
-	}
-	agg::conv_stroke<dash_t> stroke(dash);
-	stroke.line_cap(cap);
-	stroke.line_join(join);
-	stroke.width(lw);
-	theRasterizer->add_path(stroke);
-	
-      */
       dash_t dash(path);
       //dash.dash_start(offset);
-      for (size_t idash=0; idash<N/2; idash++) 
+      for (size_t idash=0; idash<Ndash/2; idash++) 
 	dash.add_dash(dasha[2*idash], dasha[2*idash+1]);
 
       agg::conv_stroke<dash_t> stroke(dash);
@@ -552,7 +524,7 @@ RendererAgg::draw_line_collection(const Py::Tuple& args) {
     }
 
     // get the color and render
-    Py::Tuple rgba = Py::Tuple(colors[ i%Nc]);
+    Py::SeqBase<Py::Object> rgba(colors[ i%Nc]);
     double r = Py::Float(rgba[0]);
     double g = Py::Float(rgba[1]);
     double b = Py::Float(rgba[2]); 
@@ -650,13 +622,13 @@ RendererAgg::draw_poly_collection(const Py::Tuple& args) {
   size_t N = (Noffsets>Nverts) ? Noffsets : Nverts;
 
   std::pair<double, double> xyo, xy;
-  Py::Tuple thisverts;
+  Py::SeqBase<Py::Object> thisverts;
   for (size_t i=0; i<N; ++i) {
 
     thisverts = verts[i % Nverts];
 
     if (usingOffsets) {
-      Py::Tuple pos = Py::Tuple(offsets[i]);
+      Py::SeqBase<Py::Object> pos = Py::SeqBase<Py::Object>(offsets[i]);
       double xo = Py::Float(pos[0]);
       double yo = Py::Float(pos[1]);
       try {
@@ -671,14 +643,14 @@ RendererAgg::draw_poly_collection(const Py::Tuple& args) {
     size_t Nverts = thisverts.length();
     agg::path_storage path;
 
-    Py::Tuple thisvert;
+    Py::SeqBase<Py::Object>  thisvert;
 
 
     // dump the verts to double arrays so we can do more efficient
     // look aheads and behinds when doing snapto pixels
     double xs[Nverts], ys[Nverts];    
     for (size_t j=0; j<Nverts; ++j) {
-      thisvert = Py::Tuple(thisverts[j]);
+      thisvert = thisverts[j];
       double x = Py::Float(thisvert[0]);
       double y = Py::Float(thisvert[1]);
       try {
@@ -730,7 +702,7 @@ RendererAgg::draw_poly_collection(const Py::Tuple& args) {
     path.close_polygon();
     int isaa = Py::Int(antialiaseds[i%Naa]);     
     // get the facecolor and render
-    Py::Tuple rgba = Py::Tuple(facecolors[ i%Nface]);
+    Py::SeqBase<Py::Object>  rgba = Py::SeqBase<Py::Object>(facecolors[ i%Nface]);
     double r = Py::Float(rgba[0]);
     double g = Py::Float(rgba[1]);
     double b = Py::Float(rgba[2]);
@@ -751,7 +723,7 @@ RendererAgg::draw_poly_collection(const Py::Tuple& args) {
     } //renderer face
 
     // get the edgecolor and render
-    rgba = Py::Tuple(edgecolors[ i%Nedge]);
+    rgba = Py::SeqBase<Py::Object>(edgecolors[ i%Nedge]);
     r = Py::Float(rgba[0]);
     g = Py::Float(rgba[1]);
     b = Py::Float(rgba[2]);
@@ -829,16 +801,16 @@ RendererAgg::draw_regpoly_collection(const Py::Tuple& args) {
   // dump the x.y vertices into a double array for faster access
   double xverts[Nverts];
   double yverts[Nverts];
-  Py::Tuple xy;
+  Py::SeqBase<Py::Object> xy;
   for (size_t i=0; i<Nverts; ++i) {
-    xy = Py::Tuple(verts[i]);
+    xy = Py::SeqBase<Py::Object>(verts[i]);
     xverts[i] = Py::Float(xy[0]);
     yverts[i] = Py::Float(xy[1]);
   }
 
   std::pair<double, double> offsetPair;
   for (size_t i=0; i<Noffsets; ++i) {
-    Py::Tuple pos = Py::Tuple(offsets[i]);
+    Py::SeqBase<Py::Object> pos = Py::SeqBase<Py::Object>(offsets[i]);
     double xo = Py::Float(pos[0]);
     double yo = Py::Float(pos[1]);
     try {
@@ -867,7 +839,7 @@ RendererAgg::draw_regpoly_collection(const Py::Tuple& args) {
     path.close_polygon();
     int isaa = Py::Int(antialiaseds[i%Naa]);     
     // get the facecolor and render
-    Py::Tuple rgba = Py::Tuple(facecolors[ i%Nface]);
+    Py::SeqBase<Py::Object> rgba = Py::SeqBase<Py::Object>(facecolors[ i%Nface]);
     double r = Py::Float(rgba[0]);
     double g = Py::Float(rgba[1]);
     double b = Py::Float(rgba[2]);
@@ -888,7 +860,7 @@ RendererAgg::draw_regpoly_collection(const Py::Tuple& args) {
     } //renderer face
 
     // get the edgecolor and render
-    rgba = Py::Tuple(edgecolors[ i%Nedge]);
+    rgba = Py::SeqBase<Py::Object>(edgecolors[ i%Nedge]);
     r = Py::Float(rgba[0]);
     g = Py::Float(rgba[1]);
     b = Py::Float(rgba[2]);