We really can not let these merges pile up over time...

WeatherGod · WeatherGod · commit bbf9bddf15f1 · 2012-03-13T14:54:25.000-05:00
Merge branch 'v1.1.x'

Conflicts:
	lib/matplotlib/backends/backend_pdf.py
	lib/matplotlib/backends/backend_ps.py
	lib/matplotlib/backends/backend_svg.py
	lib/matplotlib/markers.py
diff --git a/lib/matplotlib/backends/backend_ps.py b/lib/matplotlib/backends/backend_ps.py
@@ -613,6 +613,7 @@ def draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace=None)
 
         if stroke:
             ps_cmd.append('stroke')
+        ps_cmd.extend(['grestore', '} bind def'])
 
         for vertices, code in path.iter_segments(trans, simplify=False):
             if len(vertices):
diff --git a/lib/matplotlib/backends/backend_qt4.py b/lib/matplotlib/backends/backend_qt4.py
@@ -159,8 +159,17 @@ def __init__( self, figure ):
         w,h = self.get_width_height()
         self.resize( w, h )
 
+        # JDH: Note the commented out code below does not work as
+        # expected, because according to Pierre Raybaut, The reason is
+        # that PyQt fails (silently) to call a method of this object
+        # just before detroying it. Using a lambda function will work,
+        # exactly the same as using a function (which is not bound to
+        # the object to be destroyed).
+        #
+        #QtCore.QObject.connect(self, QtCore.SIGNAL('destroyed()'),
+        #    self.close_event)
         QtCore.QObject.connect(self, QtCore.SIGNAL('destroyed()'),
-            self.close_event)
+                               lambda: self.close_event())
 
     def __timerEvent(self, event):
         # hide until we can test and fix
diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py
@@ -128,7 +128,7 @@
     'lightcyan'            : '#E0FFFF',
     'lightgoldenrodyellow' : '#FAFAD2',
     'lightgreen'           : '#90EE90',
-    'lightgrey'            : '#D3D3D3',
+    'lightgray'            : '#D3D3D3',
     'lightpink'            : '#FFB6C1',
     'lightsalmon'          : '#FFA07A',
     'lightseagreen'        : '#20B2AA',
diff --git a/lib/matplotlib/markers.py b/lib/matplotlib/markers.py
@@ -283,13 +283,13 @@ def _set_pixel(self):
         # Ideally, you'd want -0.5, -0.5 here, but then the snapping
         # algorithm in the Agg backend will round this to a 2x2
         # rectangle from (-1, -1) to (1, 1).  By offsetting it
-        # slightly, we can force it to be (0, -1) to (1, 0), which
-        # both makes it only be a single pixel and places it correctly
-        # with 1-width stroking (i.e. the ticks).  This hack is the
-        # best of a number of bad alternatives, mainly because the
+        # slightly, we can force it to be (0, 0) to (1, 1), which both
+        # makes it only be a single pixel and places it correctly
+        # aligned to 1-width stroking (i.e. the ticks).  This hack is
+        # the best of a number of bad alternatives, mainly because the
         # backends are not aware of what marker is actually being used
         # beyond just its path data.
-        self._transform = Affine2D().translate(-0.49999, -0.50001)
+        self._transform = Affine2D().translate(-0.49999, -0.49999)
         self._snap_threshold = None
 
     def _set_point(self):
diff --git a/lib/matplotlib/path.py b/lib/matplotlib/path.py
@@ -631,7 +631,7 @@ def arc(cls, theta1, theta2, n=None, is_wedge=False):
 
         if is_wedge:
             length = n * 3 + 4
-            vertices = np.empty((length, 2), np.float_)
+            vertices = np.zeros((length, 2), np.float_)
             codes = cls.CURVE4 * np.ones((length, ), cls.code_type)
             vertices[1] = [xA[0], yA[0]]
             codes[0:2] = [cls.MOVETO, cls.LINETO]
diff --git a/src/_backend_agg.cpp b/src/_backend_agg.cpp
@@ -443,10 +443,10 @@ RendererAgg::set_clipbox(const Py::Object& cliprect, R& rasterizer)
     double l, b, r, t;
     if (py_convert_bbox(cliprect.ptr(), l, b, r, t))
     {
-        rasterizer.clip_box(std::max(int(mpl_round(l)), 0),
-                            std::max(int(height) - int(mpl_round(b)), 0),
-                            std::min(int(mpl_round(r)), int(width)),
-                            std::min(int(height) - int(mpl_round(t)), int(height)));
+        rasterizer.clip_box(std::max(int(floor(l - 0.5)), 0),
+                            std::max(int(floor(height - b - 0.5)), 0),
+                            std::min(int(floor(r - 0.5)), int(width)),
+                            std::min(int(floor(height - t - 0.5)), int(height)));
     }
     else
     {
@@ -660,7 +660,7 @@ RendererAgg::draw_markers(const Py::Tuple& args)
     // Deal with the difference in y-axis direction
     marker_trans *= agg::trans_affine_scaling(1.0, -1.0);
     trans *= agg::trans_affine_scaling(1.0, -1.0);
-    trans *= agg::trans_affine_translation(0.0, (double)height);
+    trans *= agg::trans_affine_translation(0.5, (double)height + 0.5);
 
     PathIterator       marker_path(marker_path_obj);
     transformed_path_t marker_path_transformed(marker_path, marker_trans);
@@ -746,8 +746,8 @@ RendererAgg::draw_markers(const Py::Tuple& args)
                     continue;
                 }
 
-                x = (double)(int)x;
-                y = (double)(int)y;
+                x = floor(x);
+                y = floor(y);
 
                 // Cull points outside the boundary of the image.
                 // Values that are too large may overflow and create
@@ -782,8 +782,8 @@ RendererAgg::draw_markers(const Py::Tuple& args)
                     continue;
                 }
 
-                x = (double)(int)x;
-                y = (double)(int)y;
+                x = floor(x);
+                y = floor(y);
 
                 // Cull points outside the boundary of the image.
                 // Values that are too large may overflow and create
diff --git a/src/path_converters.h b/src/path_converters.h
@@ -494,8 +494,8 @@ class PathSnapper
         code = m_source->vertex(x, y);
         if (m_snap && agg::is_vertex(code))
         {
-            *x = mpl_round(*x) + m_snap_value;
-            *y = mpl_round(*y) + m_snap_value;
+            *x = floor(*x - m_snap_value) + m_snap_value;
+            *y = floor(*y - m_snap_value) + m_snap_value;
         }
         return code;
     }

Original file line number	Diff line number	Diff line change
`@@ -494,8 +494,8 @@ class PathSnapper`
`494`	`494`	`code = m_source->vertex(x, y);`
`495`	`495`	`if (m_snap && agg::is_vertex(code))`
`496`	`496`	`{`
`497`		`- x = mpl_round(x) + m_snap_value;`
`498`		`- y = mpl_round(y) + m_snap_value;`
	`497`	`+ x = floor(x - m_snap_value) + m_snap_value;`
	`498`	`+ y = floor(y - m_snap_value) + m_snap_value;`
`499`	`499`	`}`
`500`	`500`	`return code;`
`501`	`501`	`}`